mylNLS[1., 1., 50] = 0.37158619864151443 - 0.039609366597669*I
 
mylNLS[1., 2., 50] = 0.19575544149357946 - 0.08446450307505701*I
 
mylNLS[1., 3., 50] = 0.09645466972238068 - 0.07497944318514581*I
 
mylNLS[1., 4., 50] = 0.04828923838861916 - 0.05782484634848628*I
 
mylNLS[1., 5., 50] = 0.025410161301786173 - 0.04355719210317771*I
 
mylNLS[1., 6., 50] = 0.014315362774830842 - 0.03324871472936872*I
 
mylNLS[1., 8., 50] = 0.005684068562677653 - 0.020918888616392926*I
 
mylNLS[1., 10., 50] = 0.0028910049003311204 - 0.014500891988227512*I
 
mylNLS[1., 20., 50] = 0.00044009798836907254 - 0.004788462501684096*I
 
mylNLS[1., 40., 50] = 0.00007330158947268356 - 0.0016355109106140366*I
 
mylNLS[1., 80., 50] = 0.000012264097460438648 - 0.0005481155320782296*I
 
mylNLS[1., 160., 50] = 2.1909195606157*^-6 - 0.00019896106800729*I
 
mylNLS[1., 1000., 50] = 2.191769675070834*^-8 - 0.000012634208595170598*I
 
mylNLS[2., 1., 50] = 0.2705312703485232 + 0.10501308590542738*I
 
mylNLS[2., 2., 50] = 0.2449858748992166 - 0.03636420096416831*I
 
mylNLS[2., 3., 50] = 0.15565814678768192 - 0.08226163354183902*I
 
mylNLS[2., 4., 50] = 0.09251268559480849 - 0.08300445104182756*I
 
mylNLS[2., 5., 50] = 0.055341128735753434 - 0.07129560336328086*I
 
mylNLS[2., 6., 50] = 0.03430890422281151 - 0.05857332759159407*I
 
mylNLS[2., 8., 50] = 0.015224190593170673 - 0.03949603482393319*I
 
mylNLS[2., 10., 50] = 0.008079173256977573 - 0.02810262136049036*I
 
mylNLS[2., 20., 50] = 0.0012542291324445843 - 0.0095147108735096*I
 
mylNLS[2., 40., 50] = 0.00020933328031529173 - 0.0032658116047107884*I
 
mylNLS[2., 80., 50] = 0.00003590683761805195 - 0.0011348421478249542*I
 
mylNLS[2., 160., 50] = 6.256508321876998*^-6 - 0.00039788710402929926*I
 
mylNLS[3., 1., 50] = 0.03943902937694643 + 0.14908012052202335*I
 
mylNLS[3., 2., 50] = 0.20940171964048027 + 0.09312948378227613*I
 
mylNLS[3., 3., 50] = 0.197205100817593 - 0.01427643920609177*I
 
mylNLS[3., 4., 50] = 0.14318225833304796 - 0.06062353597178747*I
 
mylNLS[3., 5., 50] = 0.09710437278799054 - 0.07147752576263527*I
 
mylNLS[3., 6., 50] = 0.06546127810706634 - 0.06810327686885534*I
 
mylNLS[3., 8., 50] = 0.031863854404306724 - 0.05246529687722361*I
 
mylNLS[3., 10., 50] = 0.017556716075995377 - 0.03935132179215436*I
 
mylNLS[3., 20., 50] = 0.0028048659928095205 - 0.014069420782628133*I
 
mylNLS[3., 40., 50] = 0.00047037012103847884 - 0.004882178617637669*I
 
mylNLS[3., 80., 50] = 0.00008081108927433968 - 0.0017017744083253805*I
 
mylNLS[3., 160., 50] = 0.000014074571382811441 - 0.0005967098725882595*I
 
mylNLS[4., 1., 50] = -0.05052674800341742 - 0.00028826447566672464*I
 
mylNLS[4., 2., 50] = 0.056237900423356926 + 0.17161810084045173*I
 
mylNLS[4., 3., 50] = 0.1672156484684982 + 0.09664153911295555*I
 
mylNLS[4., 4., 50] = 0.16911730619592358 + 0.011880650055723252*I
 
mylNLS[4., 5., 50] = 0.13634210093790772 - 0.034168572870832165*I
 
mylNLS[4., 6., 50] = 0.10219925029256105 - 0.05261587632513621*I
 
mylNLS[4., 8., 50] = 0.05579140850378272 - 0.054872447560354115*I
 
mylNLS[4., 10., 50] = 0.03232753626430056 - 0.045795415529255534*I
 
mylNLS[4., 20., 50] = 0.005422017772721869 - 0.01824866003956335*I
 
mylNLS[4., 40., 50] = 0.0009173562233447778 - 0.006467512439726592*I
 
mylNLS[4., 80., 50] = 0.00015793049111783816 - 0.0022654389429927805*I
 
mylNLS[4., 160., 50] = 0.000027518567815357318 - 0.0007953040278421774*I
 
mylNLS[5., 1., 50] = 0.037131279974081 - 0.012387260386897872*I
 
mylNLS[5., 2., 50] = -0.09320844041347633 + 0.08681786024130386*I
 
mylNLS[5., 3., 50] = 0.04647198319565213 + 0.16541431591087802*I
 
mylNLS[5., 4., 50] = 0.13258399761543327 + 0.10534134960200575*I
 
mylNLS[5., 5., 50] = 0.14596856390625168 + 0.03708075466625329*I
 
mylNLS[5., 6., 50] = 0.12874222723071327 - 0.007329515273689233*I
 
mylNLS[5., 8., 50] = 0.08281109149575616 - 0.04115618977016579*I
 
mylNLS[5., 10., 50] = 0.051633100639850646 - 0.04406224565077543*I
 
mylNLS[5., 20., 50] = 0.009365675800207866 - 0.021716465864819543*I
 
mylNLS[5., 40., 50] = 0.0016083747436229318 - 0.007993090674406044*I
 
mylNLS[5., 80., 50] = 0.00027786521054744317 - 0.0028240059917172284*I
 
mylNLS[5., 160., 50] = 0.000048456761639683286 - 0.000993455844008689*I
 
mylNLS[6., 1., 50] = -0.01594620251021027 + 0.019229098623795*I
 
mylNLS[6., 2., 50] = -0.06592516088304565 - 0.058021498165067256*I
 
mylNLS[6., 3., 50] = -0.0904611740547254 + 0.1115648406925978*I
 
mylNLS[6., 4., 50] = 0.02669497740413905 + 0.15681684765531134*I
 
mylNLS[6., 5., 50] = 0.1008402435836454 + 0.11387919249201142*I
 
mylNLS[6., 6., 50] = 0.12318343636259571 + 0.05924417986321657*I
 
mylNLS[6., 8., 50] = 0.10342554010959809 - 0.008166508419632436*I
 
mylNLS[6., 10., 50] = 0.07206315702469544 - 0.030703284242225348*I
 
mylNLS[6., 20., 50] = 0.014765883467617865 - 0.02398416025964723*I
 
mylNLS[6., 40., 50] = 0.002596073541722609 - 0.009415002600902368*I
 
mylNLS[6., 80., 50] = 0.0004509643424682483 - 0.0033736651406535323*I
 
mylNLS[6., 160., 50] = 0.00007874747214229488 - 0.0011908339693910922*I
 
mylNLS[8., 1., 50] = -0.01111832858731526 - 0.0004916281989908247*I
 
mylNLS[8., 2., 50] = 0.014189932180827591 + 0.04732288479241854*I
 
mylNLS[8., 3., 50] = 0.0003565927263912555 - 0.09353050033027614*I
 
mylNLS[8., 4., 50] = -0.12446723411460445 - 0.01433354453812584*I
 
mylNLS[8., 5., 50] = -0.09654604260386436 + 0.09820858079865434*I
 
mylNLS[8., 6., 50] = -0.01954563609463686 + 0.13518959995926771*I
 
mylNLS[8., 8., 50] = 0.07450253442551312 + 0.0904789074485502*I
 
mylNLS[8., 10., 50] = 0.08830003625735432 + 0.03366684949734616*I
 
mylNLS[8., 20., 50] = 0.02929974344462006 - 0.022306680037945566*I
 
mylNLS[8., 40., 50] = 0.005620162735648775 - 0.011680426839878646*I
 
mylNLS[8., 80., 50] = 0.0009958141853556159 - 0.004422416035658481*I
 
mylNLS[8., 160., 50] = 0.000174722745997604 - 0.001581182310179736*I
 
mylNLS[10, 1, 50] = 0.00582617884517668 - 0.0016481709673222475*I
 
mylNLS[10., 1., 50] = 0.00582617884517668 - 0.0016481709673222475*I
 
mylNLS[10., 2., 50] = 0.02674028055915128 - 0.010934448405279455*I
 
mylNLS[10., 3., 50] = 0.00023952199939801522 + 0.06177509122729961*I
 
mylNLS[10., 4., 50] = 0.07320935551701709 - 0.05649915365601914*I
 
mylNLS[10., 5., 50] = -0.04994579959997609 - 0.10190425661553053*I
 
mylNLS[10., 6., 50] = -0.12130765512406236 - 0.02164656300249971*I
 
mylNLS[10., 8., 50] = -0.06038962912365153 + 0.10345460635597814*I
 
mylNLS[10., 10., 50] = 0.023729690997731874 + 0.10123033531790213*I
 
mylNLS[10., 20., 50] = 0.044164771282788354 - 0.007918966470457554*I
 
mylNLS[10., 40., 50] = 0.010117314344365184 - 0.01253336817103149*I
 
mylNLS[10., 80., 50] = 0.0018623437279948949 - 0.005343005136173673*I
 
mylNLS[10., 160., 50] = 0.00032974795488335275 - 0.0019602599216960452*I
 
mylNLS[20., 1., 50] = 0.0006649618806283848 - 0.00042445099875018134*I
 
mylNLS[20., 2., 50] = 0.004033487412875202 - 0.0015240530430235093*I
 
mylNLS[20., 3., 50] = -0.0020179321357491273 + 0.01101288825707893*I
 
mylNLS[20., 4., 50] = 0.019637596745002046 - 0.007783426231870522*I
 
mylNLS[20., 5., 50] = 0.022578796116668652 + 0.02422548325664744*I
 
mylNLS[20., 6., 50] = -0.03932481469841599 - 0.023614232852250033*I
 
mylNLS[20., 8., 50] = 0.05442998249827548 - 0.042126748842498354*I
 
mylNLS[20., 10., 50] = -0.0823679891335177 + 0.01482064305559335*I
 
mylNLS[20., 20., 50] = -0.05865027824910185 - 0.041359616758447515*I
 
mylNLS[20., 40., 50] = 0.015765004104472687 + 0.026290563840126922*I
 
mylNLS[20., 80., 50] = 0.010726677074214467 - 0.0031562286720547995*I
 
mylNLS[20., 160., 50] = 0.002361889547839504 - 0.0031833007646486938*I
 
mylNLS[40., 1., 50] = -0.00005251108555466653 - 0.0000827189595897504*I
 
mylNLS[40., 2., 50] = 0.0002598551473471551 - 0.0004941869682974975*I
 
mylNLS[40., 3., 50] = 0.00034400706423418255 + 0.0014789749551296777*I
 
mylNLS[40., 4., 50] = 0.0025266642440165132 - 0.001724846099891297*I
 
mylNLS[40., 5., 50] = -0.0010703955591013573 - 0.0051045743652492585*I
 
mylNLS[40., 6., 50] = -0.0067418248489159276 - 0.00427503899055625*I
 
mylNLS[40., 8., 50] = 0.013528783344330837 - 0.006841899292355267*I
 
mylNLS[40., 10., 50] = -0.010219059011685273 + 0.021642832149406648*I
 
mylNLS[40., 20., 50] = 0.056467030199731635 + 0.02287425659225366*I
 
mylNLS[40., 40., 50] = -0.0378278898954315 + 0.03255822361635179*I
 
mylNLS[40., 80., 50] = -0.019872879958238346 - 0.007690015010711319*I
 
mylNLS[40., 160., 50] = 0.00452971375023656 + 0.006391773850591068*I
 
mylNLS[80., 1., 50] = -8.162537728095918*^-6 - 9.875644814199766*^-6*I
 
mylNLS[80., 2., 50] = -0.0000311265747573921 + 0.00006307960994307972*I
 
mylNLS[80., 3., 50] = 0.00014156050912604232 - 0.00013151977962416522*I
 
mylNLS[80., 4., 50] = -0.00021325323123456497 - 0.0003323665390030008*I
 
mylNLS[80., 5., 50] = 0.0006123946906272677 - 0.0003089413967102524*I
 
mylNLS[80., 6., 50] = -0.0009887116357541106 + 0.00042041879309331117*I
 
mylNLS[80., 8., 50] = 0.0009515865062118302 - 0.001945813320422123*I
 
mylNLS[80., 10., 50] = -0.0035306812518220085 + 0.001094221090988898*I
 
mylNLS[80., 20., 50] = -0.00631698125931378 - 0.015905534966863977*I
 
mylNLS[80., 40., 50] = 0.0019371694184044039 + 0.04376019348626002*I
 
mylNLS[80., 80., 50] = 0.034539784255910436 - 0.005420773778399494*I
 
mylNLS[80., 160., 50] = -0.009007443670681913 + 0.011918922680268387*I
 
mylNLS[100, 100, 50] = 0.003982645532415129 - 0.030955552394040985*I
 
mylNLS[160., 1., 50] = -9.907591469808215*^-7 - 7.512080409748621*^-7*I
 
mylNLS[160., 2., 50] = -2.4874564149776623*^-6 + 8.450771136374498*^-6*I
 
mylNLS[160., 3., 50] = -0.000023824373912497733 - 4.558778138161537*^-6*I
 
mylNLS[160., 4., 50] = -0.000029937781091202847 - 0.00003972102056122497*I
 
mylNLS[160., 5., 50] = -0.000017686897898278563 - 0.00008494757721988835*I
 
mylNLS[160., 6., 50] = 0.000011943210493269886 - 0.00013611503452748766*I
 
mylNLS[160., 8., 50] = -0.00012170948899370079 + 0.0002513409329382185*I
 
mylNLS[160., 10., 50] = 0.0002995902201237653 - 0.0003815152643840633*I
 
mylNLS[160., 20., 50] = 0.0022791327231043434 - 0.0012847793063664893*I
 
mylNLS[160., 40., 50] = -0.0108081882393299 + 0.005593672927008627*I
 
mylNLS[160., 80., 50] = -0.024285177433882994 - 0.01966491662930339*I
 
mylNLS[160., 160., 50] = 0.013604225421184947 + 0.02049759335194174*I
 
mylNLS[x_, t_, n_] := mylNLS[x, t, n] = Module[{l1, dlt, s0}, 
      l1 = 30; dlt = 0.5*I; s0 = x/2/t; f1dtrundom1 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0 + dlt - Abs[dlt] - l1, s0 + dlt - Abs[dlt]}], n}]; 
       f1dtrundom2 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0 + dlt - Abs[dlt], s0}], n/2}]; f1dtrundom3 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0, s0 + dlt - Abs[dlt] + l1 - l1*I}], n/2}]; 
       f1d1 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom1, n*3]; 
       f1d2 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom2, n]; 
       f1d3 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom3, n]; 
       I1 = 0; If[f1d1 != {}, I1 = I1 + DomainIntegrate[f1d1]/2/Pi]; 
       If[f1d2 != {}, I1 = I1 + DomainIntegrate[f1d2]/2/Pi]; 
       If[f1d3 != {}, I1 = I1 + DomainIntegrate[f1d3]/2/Pi]; 
       f2btrundom1 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0 - dlt + Abs[dlt] - l1 + l1*I, s0}], n/2}]; 
       f2btrundom2 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0, s0 - dlt + Abs[dlt]}], n/2}]; f2btrundom3 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0 - dlt + Abs[dlt], s0 - dlt + Abs[dlt] + l1}], n}]; 
       f2b1 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom1, n]; 
       f2b2 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom2, n]; 
       f2b3 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom3, n*2]; 
       I2 = 0; If[f2b1 != {}, I2 = I2 + -DomainIntegrate[f2b1]/2/Pi]; 
       If[f2b2 != {}, I2 = I2 + -DomainIntegrate[f2b2]/2/Pi]; 
       If[f2b3 != {}, I2 = I2 + -DomainIntegrate[f2b3]/2/Pi]; 
       p = 2*(Log[tol]/(-x)); f3bbtrundom1a = Truncate[tol][
         {Abs[Exp[I*#1*x]*g0h1[#1, t]*#1] & , Line[{-p + p*I + s0*I, s0*I}], 
          n}]; f3bbtrundom2 = Truncate[tol][
         {Abs[Exp[\[Theta][#1, x, t]]*g0t1[#1, Infinity]*#1] & , 
          Line[{s0*I, s0}], n}]; f3bb = 
        Join[Fun[Exp[I*#1*x]*g0h1[#1, t]*#1 & , f3bbtrundom1a, n], 
         Fun[Exp[\[Theta][#1, x, t]]*g0t1[#1, Infinity]*#1 & , f3bbtrundom2, 
          n]]; I3a = DomainIntegrate[f3bb]/Pi; f3ctrundom2 = 
        Truncate[tol][{Abs[Exp[I*#1*x - I*#1^2*t]*g0t2[#1, t]*#1] & , 
          Line[{s0*I + l1*I, s0*I}], n}]; 
       f3c = Join[Fun[Exp[I*#1*x - I*#1^2*t]*g0t2[#1, t]*#1 & , f3ctrundom2, 
          n]]; I3c = If[f3c != {}, DomainIntegrate[f3c]/Pi, 0]; 
       g3[xx_, tt_][k_] := I*k*xx - I*tt*k^2; g3[xx_, tt_][_?InfinityQ] := 0; 
       dg3[xx_, tt_][k_] := I*xx - 2*I*k*tt; dg3[xx_, tt_][_?InfinityQ] := 0; 
       g0texactk[tt_][k_] := g0t1[k, Infinity]*k; 
       g0texactk[tt_][_?InfinityQ] := 0; 
       iii = LevinInt[g0texactk[t], g3[x, t], dg3[x, t], s0, Infinity, n*2, 
          1, False]/Pi; I1 + I2 + I3a + I3c + iii]
 
x = 1.
 
t = 1000.
 
f1dtrundom1 = {}
 
Truncate[tol_][{F_, Domain_, n_}] := Module[{f1, vals, x0, dx, i, Change, 
      n0}, dx = 0.025; n0 = 100; f1 = Fun[0 & , Domain, n]; 
      vals = Table[{Abs[F[MapFromInterval[f1, x0]]] - tol, 
         MapFromInterval[f1, x0]}, {x0, -1, 1, 2/n0}]; Change = {}; 
      If[Abs[F[MapFromInterval[f1, -1]]] - tol > 0, 
       Change = {{MapFromInterval[f1, -1], 1}}; ]; 
      For[i = 1, i <= Length[vals] - 1, i++, 
       If[SignChange[vals[[i,1]], vals[[i + 1,1]]], 
        Change = Join[Change, {{If[Sign[vals[[i + 1,1]]] == 1, vals[[i,2]], 
              vals[[i + 1,2]]], Sign[vals[[i + 1,1]]]}}]; ]]; 
      If[Change != {} && Change[[-1]][[2]] == 1, 
       Change = Join[Change, {{MapFromInterval[f1, 1], -1}}]; ]; 
      CreateDomains[Change]]
 
Truncate /: Truncate::usage = "Contour truncation routine.  This requires the \
sample function, see Setrsamp[]."
 
tol = 1.*^-12
 
Domain[IFun[_List, Private`d_]] := Private`d
 
Domain[LFun[_, Private`d_]] := Private`d
 
Domain[PFun[_, Private`d_]] := Private`d
 
Domain[Private`if_SingFun] := Domain[First[Private`if]]
 
Domain /: Domain::usage = "Domain[ifun] returns the domain of an IFun."
 
IFun[Private`l_List, Private`d_][Private`z_] := 
    Private`ChebyshevLobattoBarycentricInterpolation[Private`l, 
     MapToInterval[Private`d, Private`z]]
 
Values[IFun[Private`l_List, _]] ^:= Private`l
 
(Private`f$_) /@ (Private`g$_IFun) ^:= IFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_IFun] ^:= Length[Values[Private`if]]
 
(Private`f_IFun) + (Private`g_IFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_IFun)*(Private`g_IFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_IFun) + (Private`f$_)?ConstantQ ^:= 
    IFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_IFun)*(Private`f$_)?ConstantQ ^:= 
    IFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_IFun)^(Private`c$_)?ConstantQ ^:= 
    IFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_IFun) ^:= 
    IFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_IFun)?ArrayFunQ . (Private`g_IFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
IFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_IFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_IFun] ^:= IFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_IFun] ^:= IFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_IFun] ^:= IFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_IFun] ^:= IFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_IFun] ^:= IFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_IFun] ^:= IFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_IFun] ^:= IFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_IFun] ^:= IFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_IFun] ^:= IFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_IFun] ^:= IFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_IFun] ^:= IFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_IFun] ^:= IFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_IFun] ^:= IFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_IFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_IFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_IFun] ^:= Transpose /@ Private`f
 
Max[Private`f_IFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_IFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_IFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_IFun] ^:= First[Values[Private`f]]
 
Last[Private`f_IFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_IFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_IFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_IFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_IFun] ^:= DCT[Private`f][[1]]
 
Derivative[(Private`k_)?Positive][(Private`f_IFun)?ArrayFunQ] ^:= 
    ToArrayFun[ArrayMap[Derivative[Private`k], ToArrayOfFuns[Private`f]]]
 
Derivative[0][Private`if_IFun] ^:= Private`if
 
Derivative[1][Private`if_IFun] ^:= 
    IFun[ChebyshevLobattoDerivative[Values[Private`if]], Domain[Private`if]]*
     IFun[MapToIntervalD[Private`if, #1] & , Domain[Private`if], 
      Length[Private`if]]
 
Derivative[(Private`k_)?Positive][Private`if_IFun] ^:= 
    Derivative[1][Derivative[Private`k - 1][Private`if]]
 
Derivative[Private`if_IFun] ^:= Derivative[1][Private`if]
 
Integrate[Private`if_IFun] ^:= IFun[ChebyshevLobattoIntegrate[
      Values[Private`if]*Values[IFun[MapFromIntervalD[Private`if, #1] & , 
         UnitInterval, Length[Private`if]]]], Domain[Private`if]]
 
DiagonalMatrix[Private`f_IFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_IFun] ^:= IdentityMatrix[Length[Private`f]]
 
Roots[Private`cf_IFun] ^:= MapFromInterval[Private`cf, 
     Sort[Re[Select[ComplexRoots[ToUnitInterval[Private`cf]], 
        Abs[Im[#1]] < 100*$MachineTolerance && -1. <= Re[#1] <= 1. & ]]]]
 
Minimize[Private`cf_IFun] ^:= 
    Second[First[Sort[(Thread[{Abs[Private`cf /@ #1], #1}] & )[
        Join[Roots[Derivative[1][Private`cf]], Endpoints[Private`cf]]]]]]
 
IFun[(Private`f_)?NotListOrPatternQ, Private`d_, Private`n_Integer] := 
    IFun[Private`f /@ IntervalPoints[Private`d, Private`n], Private`d]
 
IFun[Private`a_] := IFun[Private`a, UnitInterval]
 
IFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts:OptionsPattern[]] := Private`AdaptiveIFun[4, Private`f, 
     Private`d, Private`opts]
 
MakeBoxes[Private`f:IFun[Private`l_List, _], FormatType_] ^:= 
    Format[ReImLinePlot[Private`f, Sequence @@ $FunFormat], FormatType]
 
Format[Private`f:IFun[Private`l_List, _]] := ReImLinePlot[Private`f, 
     Sequence @@ $FunFormat]
 
Options[IFun] := {InterpolationPrecision -> $MachineTolerance}
 
IFun /: IFun::usage = "IFun[\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\
,d,n] constructs an \!\(\*\nStyleBox[\"n\",\nFontSlant->\"Italic\"]\)-th \
order Chebyshev approximation of \
\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\) over the domain d, which is \
either a Line or \
Arc\!\(\*\nStyleBox[\".\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)IFun\!\(\*\nStyleBox[\"[\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\",\",\
\nFontSlant->\"Italic\"]\)d\!\(\*\nStyleBox[\"]\",\nFontSlant->\"Italic\"]\)\
\!\(\*\nStyleBox[\" \",\nFontSlant->\"Italic\"]\)chooses n adaptively. \
\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)IFun\!\(\*\nStyleBox[\"[\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\",\",\
\nFontSlant->\"Italic\"]\)d\!\(\*\nStyleBox[\",\",\nFontSlant->\"Italic\"]\)I\
nterpolationPrecision\[Rule]tol] chooses n adaptively, so that the last two \
Chebyshev coefficients are less than tol. If f is a constructed IFun, then \
f[x] evaluates the approximation at the point x. Operations that can be \
applied to an IFun include standard mathematical functions (Abs, Sin, Exp, \
etc.) and operators Integrate (returning the indefinite integral) and \
Derivative[k]."
 
Private`ChebyshevLobattoBarycentricInterpolation[Private`f_List, 
     Private`x_] := Module[{Private`w, Private`j, Private`p, Private`k, 
      Private`n}, Private`k = Length[Private`f]; 
      Private`n = NChebyshevLobattoPoints[Private`k]; Private`w[1] = 1/2; 
      Private`w[Private`j_] = (-1)^(Private`j + 1); Private`w[Private`k] = 
       ((-1)^(Private`k + 1)*1)/2; If[MemberQ[Private`n, 
        N[Chop[Private`x, $MachineEpsilon]]], Private`f[[
        Position[Private`n, N[Chop[Private`x, $MachineEpsilon]]][[1,1]]]], 
       Sum[(Private`w[Private`j]/(Private`x - Private`n[[Private`j]]))*
          Private`f[[Private`j]], {Private`j, 1, Private`k}]/
        Sum[Private`w[Private`j]/(Private`x - Private`n[[Private`j]]), 
         {Private`j, 1, Private`k}]]]
 
NChebyshevLobattoPoints[Private`n_, Private`a_:-1., Private`b_:1.] := 
    0.5*(Private`b + Private`a) + 0.5*(Private`b - Private`a)*
      Cos[(Pi*Range[Private`n - 1., 0., -1.])/(Private`n - 1)]
 
Attributes[MapToInterval] = {Listable}
 
MapToInterval[Line[{_?InfinityQ, _?InfinityQ}], Private`y_] := 
    RealLineToInterval[Private`y]
 
MapToInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`z_] := HalfLineToInterval[
     (Exp[-(I*Arg[Private`b])]*(Private`z - Private`a))/Private`L]
 
MapToInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`z_] := 
    -MapToInterval[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      Private`z]
 
MapToInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`z_] := MapToInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`z_] := MapToInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToInterval[Line[{Private`a_, Private`b_}], Private`z_] := 
    (Private`a + Private`b - 2*Private`z)/(Private`a - Private`b)
 
MapToInterval[Private`z_] := Private`z
 
MapToInterval[Line[{Private`a_, Private`b_}, 
      Stretch -> _?(NEqual[1., #1] & )], _?InfinityQ] := Infinity
 
MapToInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     _?InfinityQ] := (1 + Private`L)/(1 - Private`L)
 
MapToInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (-Private`a - Private`b*Private`L + 
      (1 + Private`L)*Private`z)/(-Private`a + Private`b*Private`L + 
      Private`z - Private`L*Private`z)
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
      Private`z_] /; NEqual[-(E^((1*I*(Private`t0 + Private`t1))/2)*
         Private`r) + Private`z0, Private`z] := Infinity
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     _?InfinityQ] := -((E^((I*Private`t0)/2) + E^((I*Private`t1)/2))/
      (E^((I*Private`t0)/2) - E^((I*Private`t1)/2)))
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`z_] := -(((E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
       (E^((I*Private`t0)/2 + (I*Private`t1)/2)*Private`r - Private`z + 
        Private`z0))/((-E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
       (E^((I*Private`t0)/2 + (I*Private`t1)/2)*Private`r + Private`z - 
        Private`z0)))
 
MapToInterval[Private`f_IFun, Private`z_] := MapToInterval[Domain[Private`f], 
     Private`z]
 
MapToInterval[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapToInterval[Curve[Private`cr_], Private`z_] /; NEqual[Private`z, 
      First[Private`cr]] := -1.
 
MapToInterval[Curve[Private`cr_], Private`z_] /; NEqual[Private`z, 
      Last[Private`cr]] := 1.
 
MapToInterval[Curve[Private`cr_], Private`z_] := 
    (If[#1 == {}, {}, First[#1]] & )[Roots[Private`cr - Private`z]]
 
MapToInterval[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapToInterval[Line[{-1, 1}, Stretch -> Private`L], 
     MapToInterval[Curve[Private`cr], Private`z]]
 
MapToInterval /: MapToInterval::usage = "MapToInterval[d,x] maps the point x \
via the conformal map that maps the domain d to the unit interval. If d is an \
IFun, then it is equivalent to MapToInterval[Domain[d],x]."
 
InfinityQ[-Infinity] := True
 
InfinityQ[Infinity] := True
 
InfinityQ[_DirectedInfinity] := True
 
InfinityQ[_] := False
 
InfinityQ /: InfinityQ::usage = "Test for whether a value is infinite."
 
Attributes[RealLineToInterval] = {Listable}
 
RealLineToInterval[(Private`y_)?NumberQ] := Private`y/Sqrt[1 + Private`y^2]
 
Stretch /: Stretch::usage = "Stretch is a possible parameter for Line used in \
determining the conformal map."
 
Attributes[HalfLineToInterval] = {Listable}
 
HalfLineToInterval[(Private`y_)?InfinityQ] := 1.
 
HalfLineToInterval[Private`y_] /; Private`y == -1 := Infinity
 
HalfLineToInterval[Private`y_] := (-1 + Private`y)/(1 + Private`y)
 
NEqual[Private`f:{__?FunQ}, Private`g:{__?FunQ}] := 
    Norm[Norm /@ (Private`f - Private`g)] < $MachineTolerance
 
NEqual[Private`f_List, Private`g_List] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[_?InfinityQ, _?InfinityQ] := True
 
NEqual[Private`f_IFun, Private`g_IFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Line[Private`ls_, ___], Line[Private`ls2_, ___]] := 
    NZeroQ[Max[Abs[Flatten[(If[#1[[1]] == #1[[2]], 0, 
           #1[[1]] - #1[[2]]] & ) /@ Thread[{Sort[Private`ls], 
           Sort[Private`ls2]}]]]]]
 
NEqual[Arc[Private`x0_, Private`r_, Private`t0_], 
     Arc[Private`x2_, Private`r2_, Private`t2_]] := 
    NZeroQ[Max[Abs[Flatten[{Private`x0 - Private`x2, Private`r - Private`r2, 
         Exp[I*Private`t0] - Exp[I*Private`t2]}]]]]
 
NEqual[Private`f_LFun, Private`g_LFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Private`f_PFun, Private`g_PFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Curve[Private`f_, Private`opts___], Curve[Private`g_, 
      Private`opts___]] := If[Length[Private`f] == Length[Private`g], 
     Norm[Values[Private`f - Private`g]] < $MachineTolerance, False]
 
NEqual[Private`f_SingFun, Private`g_SingFun] := 
    Norm[Values[Private`f - Private`g]] < $MachineTolerance
 
NEqual[Private`f_, Private`g_] := Abs[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual /: NEqual::usage = "NEqual[i,j] determines whether two values are \
within $MachineTolerence of each other."
 
FunQ[_IFun] := True
 
FunQ[_LFun] := True
 
FunQ[_PFun] := True
 
FunQ[_] := False
 
FunQ /: FunQ::usage = "Tests if an object is in IFun or LFun."
 
LFun[Private`l_List, Private`d_][Private`z_] := 
    MapDot[MapToCircle[Private`d, Private`z]^#1 & , FFT[Private`l]]
 
Values[LFun[Private`l_List, _]] ^:= Private`l
 
(Private`f$_) /@ (Private`g$_LFun) ^:= LFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_LFun] ^:= Length[Values[Private`if]]
 
(Private`f_LFun) + (Private`g_LFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_LFun)*(Private`g_LFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_LFun) + (Private`f$_)?ConstantQ ^:= 
    LFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_LFun)*(Private`f$_)?ConstantQ ^:= 
    LFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_LFun)^(Private`c$_)?ConstantQ ^:= 
    LFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_LFun) ^:= 
    LFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_LFun)?ArrayFunQ . (Private`g_LFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
LFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_LFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_LFun] ^:= LFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_LFun] ^:= LFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_LFun] ^:= LFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_LFun] ^:= LFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_LFun] ^:= LFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_LFun] ^:= LFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_LFun] ^:= LFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_LFun] ^:= LFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_LFun] ^:= LFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_LFun] ^:= LFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_LFun] ^:= LFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_LFun] ^:= LFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_LFun] ^:= LFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_LFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_LFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_LFun] ^:= Transpose /@ Private`f
 
Max[Private`f_LFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_LFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_LFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_LFun] ^:= First[Values[Private`f]]
 
Last[Private`f_LFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_LFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_LFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_LFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_LFun] ^:= FFT[Private`f][[0]]
 
Derivative[0][Private`if_LFun] ^:= Private`if
 
Derivative[1][Private`f_LFun] ^:= 
    (#1*LFun[MapToCircleD[Private`f, #1] & , Domain[Private`f], 
        Length[#1]] & )[LFun[InverseFFT[PadRight[
        ShiftLeft[MapOuter[#1 & , FFT[Private`f]]], Length[Private`f] + 2]], 
      Domain[Private`f]]]
 
Derivative[(Private`k_)?Positive][Private`if_LFun] ^:= 
    Derivative[1][Derivative[Private`k - 1][Private`if]]
 
Derivative[Private`if_LFun] ^:= Derivative[1][Private`if]
 
Integrate[Private`lf_LFun, Private`z_] ^:= 
    BoundedIntegrate[Private`lf][Private`z] + DomainIntegrate[Private`lf]*
      (Log[MapToCircle[Private`lf, Private`z]]/(2*Pi*I) - 
       Piecewise[{{-2^(-1), NEqual[MapToCircle[Private`lf, Infinity], -1]}, 
         {Log[MapToCircle[Private`lf, Infinity]]/(2*Pi*I), True}}])
 
Reverse[Private`lf:LFun[_, Line[{-Infinity, Infinity}, ___]]] ^:= 
    LFun[Join[{Values[Private`lf][[1]]}, Reverse[Rest[Values[Private`lf]]]], 
     Domain[Private`lf]]
 
DiagonalMatrix[Private`f_LFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_LFun] ^:= IdentityMatrix[Length[Private`f]]
 
Roots[Private`lf_LFun] ^:= Module[{Private`dct}, 
     Private`dct = ToList[RemoveZeros[Chop[FFT[Private`lf], 
          $MachineTolerance]]]; MapFromCircle[Private`lf, 
       Select[Eigenvalues[Transpose[Join[Transpose[SparseArray[
             {Private`i_, Private`j_} /; Private`j == Private`i - 1 -> 1, 
             {Length[Private`dct] - 1, Length[Private`dct] - 2}]], 
           -({Most[Private`dct]}/Last[Private`dct])]]], 
        Abs[Abs[#1] - 1] < 10.^(-6) & ]]]
 
LFun /: ToeplitzMatrix[Private`lf_LFun, Private`n_Integer] := 
     ToeplitzMatrix[FFT[Private`lf], Private`n]
 
LFun /: HankelMatrix[Private`lf_LFun, Private`n_Integer] := 
     HankelMatrix[FFT[Private`lf], Private`n]
 
LFun[Private`f_, Private`d_, Private`n_] := 
    LFun[Private`f /@ MapFromCircle[Private`d, Points[UnitCircle, 
        Private`n]], Private`d]
 
LFun[Private`l_ShiftList, Private`d_] := 
    LFun[InverseFFT[MakeFFTIndexRange[Private`l]], Private`d]
 
LFun[Private`f_IFun] := LFun[Join[Values[Private`f], 
      Reverse[Values[Private`f]][[2 ;; -2]]], UnitCircle]
 
LFun[Private`a_] := LFun[Private`a, UnitCircle]
 
LFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts:OptionsPattern[]] := Private`AdaptiveLFun[8, Private`f, 
     Private`d, Private`opts]
 
MakeBoxes[Private`f:LFun[Private`l_List, _], FormatType_] ^:= 
    Format[ReImLinePlot[Private`f, Sequence @@ $FunFormat], FormatType]
 
Format[Private`f:LFun[Private`l_List, _]] := ReImLinePlot[Private`f, 
     Sequence @@ $FunFormat]
 
Options[LFun] := {InterpolationPrecision -> $MachineTolerance}
 
LFun /: LFun::usage = "LFun[\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\
,d,n] constructs an \!\(\*\nStyleBox[\"n\",\nFontSlant->\"Italic\"]\)-th \
order Laurent approximation of \
\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\) over the domain d, which is \
either a Circle or the real line \
Line[{-\[Infinity],\[Infinity]}]\!\(\*\nStyleBox[\".\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"  \",\nFontSlant->\"Italic\"]\)If f is a constructed \
LFun, then\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\
\)[x] evaluates the approximation at the point x. Operations that can be \
applied to an LFun include standard mathematical functions (Abs,Sin,Exp,etc.) \
and operators Integrate (returning the indefinite integral) and \
Derivative[k]."
 
MapDot[Private`f_, Private`ls_List] := Module[{Private`k}, 
     Sum[Private`ls[[Private`k]]*Private`f[Private`k], 
      {Private`k, 1, Length[Private`ls]}]]
 
MapDot[Private`m_, Private`lst_ShiftList] := Module[{Private`k}, 
     Sum[Private`lst[[Private`k]]*Private`m[Private`k], 
      {Private`k, FirstIndex[Private`lst], LastIndex[Private`lst]}]]
 
Attributes[ShiftList] = {NHoldRest}
 
ShiftList[Private`ln_List, Private`ind_Integer][[Private`j_]] ^:= 
    Private`ln[[Private`fixind[Private`j, Private`ind, Length[Private`ln]]]]
 
Length[Private`l_ShiftList] ^:= Length[ToList[Private`l]]
 
Drop[Private`l_ShiftList, Private`n_] ^:= 
    ShiftList[Drop[ToList[Private`l], Private`n], Index[Private`l] - 
      Private`n]
 
(Private`ln_ShiftList) + (Private`ln2_ShiftList) ^:= 
    Module[{Private`lnn, Private`lnn2}, 
     Private`lnn = IncreaseIndexRange[Private`ln, IndexRange[Private`ln2]]; 
      Private`lnn2 = IncreaseIndexRange[Private`ln2, IndexRange[Private`ln]]; 
      ShiftList[ToList[Private`lnn] + ToList[Private`lnn2], 
       Index[Private`lnn]]]
 
(Private`c_) + ShiftList[Private`ln_, Private`ind_] ^:= 
    ShiftList[Private`ln + Private`c, Private`ind]
 
(Private`sl1_ShiftList) . (Private`sl2_ShiftList) ^:= 
    Module[{Private`indm, Private`indM}, 
     Private`indm = Max[FirstIndex[Private`sl1], FirstIndex[Private`sl2]]; 
      Private`indM = Min[LastIndex[Private`sl1], LastIndex[Private`sl2]]; 
      If[Private`indM < Private`indm, 0, 
       Private`sl1[[Private`indm ;; Private`indM]] . 
        Private`sl2[[Private`indm ;; Private`indM]]]]
 
ShiftList[Private`ln_, Private`ind_]*ShiftList[Private`ln2_, 
      Private`ind_] ^:= ShiftList[Private`ln*Private`ln2, Private`ind]
 
(Private`c_)*ShiftList[Private`ln_, Private`ind_] ^:= 
    ShiftList[Private`c*Private`ln, Private`ind]
 
ListConvolve[Private`a_ShiftList, Private`b_ShiftList, Private`opts___] ^:= 
    ShiftList[ListConvolve[ToList[Private`a], ToList[Private`b], 
      Private`opts], Index[Private`a]]
 
RotateLeft[Private`a_ShiftList, Private`opts___] ^:= 
    ShiftList[RotateLeft[ToList[Private`a], Private`opts], Index[Private`a]]
 
PadRight[Private`f_ShiftList, Private`n_] ^:= 
    ShiftList[PadRight[ToList[Private`f], Private`n, 
      {If[Length[Private`f] == 0, 0, ToList[Private`f][[1]]*0]}], 
     Index[Private`f]]
 
PadLeft[Private`f_ShiftList, Private`n_] ^:= 
    ShiftList[PadLeft[ToList[Private`f], Private`n, 
      {If[Length[Private`f] == 0, 0, ToList[Private`f][[1]]*0]}], 
     Index[Private`f] + Private`n - Length[Private`f]]
 
Append[Private`f_ShiftList, Private`el_] ^:= 
    ShiftList[Append[ToList[Private`f], Private`el], Index[Private`f]]
 
Riffle[Private`sl_ShiftList, Private`x_] ^:= 
    ShiftList[Riffle[ToList[Private`sl], Private`x], Index[Private`sl]*2 - 1]
 
Reverse[Private`sl_ShiftList] ^:= ShiftList[Reverse[ToList[Private`sl]], 
     Length[Private`sl] - Index[Private`sl] + 1]
 
MatrixForm[ShiftList[Private`l_, Private`ind_Integer]] ^:= 
    MatrixForm[Join[Private`l[[1 ;; Private`ind - 1]], 
      {Style[Private`l[[Private`ind]], Bold]}, 
      Private`l[[Private`ind + 1 ;; -1]]]]
 
(Private`f_) @@ ShiftList[Private`l_, _] ^:= Private`f @@ Private`l
 
(Private`f_) /@ ShiftList[Private`l_, Private`ind_] ^:= 
    ShiftList[Private`f /@ Private`l, Private`ind]
 
MapIndexed[Private`f_, ShiftList[Private`ln_, Private`ind_]] ^:= 
    ShiftList[MapIndexed[Private`f[#1, #2 - Private`ind] & , Private`ln], 
     Private`ind]
 
ReplacePart[Private`sl_ShiftList, Private`pat_] ^:= 
    ShiftList[MapIndexed[
      If[Or @@ Function[Private`pm, MatchQ[First[#2] - Index[Private`sl], 
            Private`pm]] /@ First /@ Private`pat, 
        First[#2] - Index[Private`sl] /. Private`pat, #1] & , 
      ToList[Private`sl]], Index[Private`sl]]
 
Abs[Private`f_ShiftList] ^:= Abs /@ Private`f
 
Re[Private`f_ShiftList] ^:= Re /@ Private`f
 
Im[Private`f_ShiftList] ^:= Im /@ Private`f
 
Indices[Private`sl_ShiftList] ^:= Array[#1 - Index[Private`sl] & , 
     Length[Private`sl]]
 
Private`LinePlot[Private`sl_ShiftList, Private`opts___] ^:= 
    ListLinePlot[Thread[{Indices[Private`sl], ToList[Private`sl]}], 
     Private`opts]
 
ListLogPlot[Private`sl_ShiftList, Private`opts___] ^:= 
    ListLogPlot[Thread[{Indices[Private`sl], ToList[Private`sl]}], 
     Private`opts]
 
ShiftList /: ToeplitzMatrix[Private`sl_ShiftList, Private`n_Integer] := 
     Transpose[ToeplitzMatrix[PadRight[Reverse[NonPositiveList[Private`sl]], 
        Private`n], PadRight[NonNegativeList[Private`sl], Private`n]]]
 
ToeplitzMatrix[Private`sl_ShiftList] ^:= ToeplitzMatrix[Private`sl, 
     Length[Private`sl]]
 
ShiftList /: HankelMatrix[Private`sl_ShiftList, Private`n_Integer] := 
     Transpose[HankelMatrix[PadRight[PositiveList[Private`sl], Private`n]]]
 
ShiftList[Private`ln_List, Private`lp_List] := 
    ShiftList[Join[Private`ln, Private`lp], Length[Private`ln] + 1]
 
MakeBoxes[ShiftList[Private`l_, Private`ind_Integer], FormatType_] ^:= 
    Format[If[0 < Private`ind < Length[Private`l], 
      Join[Private`l[[1 ;; Private`ind - 1]], 
       {Style[Private`l[[Private`ind]], Bold]}, 
       Private`l[[Private`ind + 1 ;; -1]]], Private`l], FormatType]
 
Format[ShiftList[Private`l_, Private`ind_Integer]] := 
    If[0 < Private`ind < Length[Private`l], 
     Join[Private`l[[1 ;; Private`ind - 1]], 
      {Style[Private`l[[Private`ind]], Bold]}, 
      Private`l[[Private`ind + 1 ;; -1]]], Private`l]
 
Private`fixind[Private`a_Integer, Private`ind_] := Private`a + Private`ind
 
Private`fixind[All, Private`ind_] := All
 
Private`fixind[All ;; (Private`b_Integer), Private`ind_] := 
    1 ;; Private`b + Private`ind
 
Private`fixind[(Private`a_Integer) ;; (Private`b_Integer), Private`ind_] := 
    Private`a + Private`ind ;; Private`b + Private`ind
 
Private`fixind[(Private`a_Integer) ;; All, Private`ind_] := 
    Private`a + Private`ind ;; All
 
Private`fixind[All ;; All, Private`ind_] := 1 ;; All
 
Private`fixind[Private`a_Integer, Private`ind_, Private`n_] := 
    Mod[Private`a + Private`ind - 1, Private`n] + 1
 
Private`fixind[All, Private`ind_, Private`n_] := All
 
Private`fixind[All ;; (Private`b_Integer), Private`ind_, Private`n_] := 
    1 ;; Private`fixind[Private`b, Private`ind, Private`n]
 
Private`fixind[(Private`a_Integer) ;; (Private`b_Integer), Private`ind_, 
     Private`n_] := Private`fixind[Private`a, Private`ind, Private`n] ;; 
     Private`fixind[Private`b, Private`ind, Private`n]
 
Private`fixind[(Private`a_Integer) ;; All, Private`ind_, Private`n_] := 
    Private`fixind[Private`a, Private`ind, Private`n] ;; All
 
Private`fixind[All ;; All, Private`ind_, Private`n_] := 1 ;; All
 
ToList[ShiftList[Private`ln_, _]] := Private`ln
 
ToList[Private`ln_List] := Private`ln
 
Index[ShiftList[_, Private`ind_]] := Private`ind
 
IncreaseIndexRange[Private`sl_ShiftList, Private`ind_] := 
    Module[{Private`sl2}, Private`sl2 = PadLeft[Private`sl, 
        Length[Private`sl] + Max[0, FirstIndex[Private`sl] - 
           First[Private`ind]]]; PadRight[Private`sl2, 
       Length[Private`sl2] + Max[0, Last[Private`ind] - 
          LastIndex[Private`sl]]]]
 
FirstIndex[Private`l_ShiftList] := 1 - Index[Private`l]
 
LastIndex[Private`l_ShiftList] := Length[Private`l] - Index[Private`l]
 
IndexRange[Private`l_ShiftList] := {FirstIndex[Private`l], 
     LastIndex[Private`l]}
 
NonPositiveList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[1 ;; Private`ind]]
 
NonNegativeList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[Private`ind ;; -1]]
 
PositiveList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[Private`ind + 1 ;; -1]]
 
Attributes[MakeBoxes] = {HoldAllComplete}
 
Attributes[MapToCircle] = {Listable}
 
MapToCircle[Circle[Private`a_, Private`r_], Private`z_] := 
    (Private`z - Private`a)/Private`r
 
MapToCircle[Circle[Private`a_, Private`r_, Orientation -> 1], Private`z_] := 
    (Private`z - Private`a)/Private`r
 
MapToCircle[Circle[Private`a_, Private`r_, Orientation -> -1], Private`z_] := 
    Private`r/(Private`z - Private`a)
 
MapToCircle[Line[{-Infinity, Infinity}], _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}], _?(NEqual[#1, -I] & )] := Infinity
 
MapToCircle[Line[{-Infinity, Infinity}], Private`t_] := 
    (I - Private`t)/(I + Private`t)
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`t_] := (I - Private`L*Private`t)/(I + Private`L*Private`t)
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], Private`t_] := 
    (I - Private`L*(Private`t - Private`a))/
     (I + Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`t_] := 
    (I + I*Private`L*(Private`t - Private`a))/
     (I - I*Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`t_] := 
    (I - I*Private`L*(Private`t - Private`a))/
     (I + I*Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{-Pi, Pi}], Private`z_] := Exp[I*Private`z]
 
MapToCircle[Private`l_Line, Private`z_] := 
    MapToCircle[Private`PeriodicInterval, MapToInterval[Private`l, Private`z]*
      Pi]
 
MapToCircle[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapToCircle[Circle[0, Private`r], IntervalToInnerCircle[
      MapToInterval[Line[{Private`a, Private`b}], Private`z]]]
 
MapToCircle[Private`f_LFun, Private`z_] := MapToCircle[Domain[Private`f], 
     Private`z]
 
MapToCircle[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapToCircle[Curve[Private`cr_], Private`z_] := 
    First[Roots[Private`cr - Private`z]]
 
MapToCircle /: MapToCircle::usage = "MapToCircle[d,z] maps z via the \
conformal map from the domain d to the unit circle."
 
Centre /: Centre::usage = "Centre is a possible parameter for Line used in \
determining the conformal map."
 
Private`PeriodicInterval = Line[{-Pi, Pi}]
 
Ellipse[Private`r_] := Ellipse[{-1, 1}, Private`r]
 
Ellipse /: Ellipse::usage = "Ellipse[{a_,b_},r] represents the Bernstein \
ellipse arond the interval (a,b)."
 
Attributes[IntervalToInnerCircle] = {Listable}
 
IntervalToInnerCircle[(Private`t_)?InfinityQ] := 0
 
IntervalToInnerCircle[Private`t_] := Private`t - Sqrt[Private`t - 1]*
      Sqrt[Private`t + 1]
 
Conjugate[Curve[Private`cr_IFun, Private`opts___]] ^:= 
    Curve[Conjugate[Private`cr], Private`opts]
 
Curve[Private`cr_IFun, Private`opts___] + (Private`c_)?NumberQ ^:= 
    Curve[Private`c + Private`cr, Private`opts]
 
Curve[Private`cr_IFun, Private`opts___]*(Private`c_)?NumberQ ^:= 
    Curve[Private`c*Private`cr, Private`opts]
 
Curve /: Curve::usage = "Turns an IFun into a domain"
 
FFT[Private`f:{__?ScalarQ}] := Module[{Private`c, Private`cc, Private`n, 
      Private`scale, Private`k}, Private`n = Length[Private`f]; 
      Private`scale = Sqrt[1.*Private`n]; Private`cc = 
       -((Reverse[AlternatingVector[Private`n]]*Fourier[Private`f])/
         Private`scale); Private`c[0] = (-1)^Private`n*Private`cc[[1]]; 
      Private`c[Private`k_] /; Private`k < 0 := (-1)^Private`n*
        Private`cc[[1 - Private`k]]; Private`c[Private`k_] /; 
        Private`k > 0 := Private`cc[[-Private`k]]; If[EvenQ[Private`n], 
       ShiftList[Table[Private`c[Private`k], {Private`k, -(Private`n/2), 
          -1}], Table[Private`c[Private`k], {Private`k, 0, 
          Private`n/2 - 1}]], ShiftList[Table[Private`c[Private`k], 
         {Private`k, -((Private`n - 1)/2), -1}], Table[Private`c[Private`k], 
         {Private`k, 0, (Private`n - 1)/2}]]]]
 
FFT[Private`f:{__?ArrayQ}] := ToShiftListOfArrays[
     Map[FFT, ToArrayOfLists[Private`f], {-2}]]
 
FFT[Private`if_LFun] := FFT[Values[Private`if]]
 
FFT /: FFT::usage = 
     "Returns a ShiftList of Laurent coefficients of a LFun or its value \
list."
 
ScalarQ[Private`f_] := NumberQ[N[Private`f]]
 
ScalarQ /: ScalarQ::usage = "Tests whether something has a scalar value."
 
Private`cc[Private`z_] := Conjugate[Private`z]
 
AlternatingVector[Private`n_] := Table[(-1)^(Private`k + 1), 
     {Private`k, Private`n}]
 
AlternatingVector /: AlternatingVector::usage = "Alternating vector."
 
ToShiftListOfArrays[Private`ar_] := ShiftList[ToListOfArrays[
      ArrayMap[ToList, Private`ar]], Index[Flatten[Private`ar][[1]]]]
 
ToListOfArrays[(Private`A_)?MatrixQ] := Transpose[Private`A]
 
ToListOfArrays[(Private`A_)?(Length[Dimensions[#1]] == 3 & )] := 
    ToListOfMatrices[Private`A]
 
ToListOfArrays[(Private`A_)?VectorQ] := Private`A
 
ToListOfMatrices[Private`gg_] := Array[Private`gg[[All,All,#1]] & , 
     Length[First[First[Private`gg]]]]
 
ArrayMap[Private`f_, (Private`m_)?MatrixQ] := MatrixMap[Private`f, Private`m]
 
ArrayMap[Private`f_, (Private`m_)?VectorQ] := Private`f /@ Private`m
 
ArrayMap[Private`f_, (Private`m_)?TensorQ] := 
    (MatrixMap[Private`f, #1] & ) /@ Private`m
 
ArrayMap[Private`f_, Private`m_ShiftList] := ArrayMap[Private`f, 
     ToArrayOfShiftLists[Private`m]]
 
ArrayMap[Private`f_, (Private`g_)?ScalarFunQ] := Private`f[Private`g]
 
ArrayMap[Private`f_, (Private`g_)?FunQ] := ArrayMap[Private`f, 
     ToArrayOfFuns[Private`g]]
 
ArrayMap[Private`f_, Private`m_] := Private`f[Private`m]
 
MatrixMap[Private`f_, (Private`g_)?FunQ] := MatrixMap[Private`f, 
     ToMatrixOfFuns[Private`g]]
 
MatrixMap[Private`f_, Private`m_] := Map[Private`f, Private`m, {2}]
 
ToMatrixOfFuns[Private`f_] := MatrixMap[
     Head[Private`f][#1, Domain[Private`f]] & , ToMatrixOfLists[
      Values[Private`f]]]
 
ToMatrixOfFuns /: ToMatrixOfFuns::usage = 
     "Changes an IFun whose values are a matrix to a matrix of IFuns"
 
ToMatrixOfLists[Private`g1_] := Array[Private`g1[[All,#1,#2]] & , 
     Dimensions[First[Private`g1]]]
 
ToArrayOfShiftLists[Private`sl_] := Map[ShiftList[#1, Index[Private`sl]] & , 
     ToArrayOfLists[ToList[Private`sl]], {-2}]
 
ToArrayOfLists[(Private`A_)?MatrixQ] := Transpose[Private`A]
 
ToArrayOfLists[(Private`A_)?(Length[Dimensions[#1]] == 3 & )] := 
    ToMatrixOfLists[Private`A]
 
ToArrayOfLists[(Private`A_)?VectorQ] := Private`A
 
ScalarFunQ[(Private`f_)?FunQ] := ScalarQ[First[Values[Private`f]]]
 
ScalarFunQ[_] := False
 
ToArrayOfFuns[(Private`f_)?MatrixFunQ] := ToMatrixOfFuns[Private`f]
 
ToArrayOfFuns[(Private`f_)?VectorFunQ] := 
    (Head[Private`f][#1, Domain[Private`f]] & ) /@ 
     ToArrayOfLists[Values[Private`f]]
 
ToArrayOfFuns[(Private`f_)?ScalarFunQ] := Private`f
 
MatrixFunQ[(Private`f_)?FunQ] := MatrixQ[First[Values[Private`f]]]
 
MatrixFunQ[_] := False
 
MatrixFunQ /: MatrixFunQ::usage = 
     "Tests if an object is in IFun whose values are a matrix."
 
VectorFunQ[(Private`f_)?FunQ] := VectorQ[First[Values[Private`f]]]
 
VectorFunQ[_] := False
 
VectorFunQ /: VectorFunQ::usage = 
     "Tests if an object is in IFun whose values are a vector."
 
Attributes[Private`f$] = {Temporary}
 
Attributes[Private`g$] = {Temporary}
 
FastPlus[Private`f$__IFun] := IFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__LFun] := LFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__PFun] := PFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__SingFun] := SingFun[Head[First[First[{Private`f$}]]][
      Plus @@ Values /@ {Private`f$}, Domain[First[First[{Private`f$}]]]], 
     Second[First[{Private`f$}]]]
 
PFun[Private`c0_, Private`d_][Private`z_] := Private`c0[[1]]
 
Values[PFun[Private`c0_, _]] ^:= Private`c0
 
(Private`f$_) /@ (Private`g$_PFun) ^:= PFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_PFun] ^:= Length[Values[Private`if]]
 
(Private`f_PFun) + (Private`g_PFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_PFun)*(Private`g_PFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_PFun) + (Private`f$_)?ConstantQ ^:= 
    PFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_PFun)*(Private`f$_)?ConstantQ ^:= 
    PFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_PFun)^(Private`c$_)?ConstantQ ^:= 
    PFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_PFun) ^:= 
    PFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_PFun)?ArrayFunQ . (Private`g_PFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
PFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_PFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_PFun] ^:= PFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_PFun] ^:= PFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_PFun] ^:= PFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_PFun] ^:= PFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_PFun] ^:= PFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_PFun] ^:= PFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_PFun] ^:= PFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_PFun] ^:= PFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_PFun] ^:= PFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_PFun] ^:= PFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_PFun] ^:= PFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_PFun] ^:= PFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_PFun] ^:= PFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_PFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_PFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_PFun] ^:= Transpose /@ Private`f
 
Max[Private`f_PFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_PFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_PFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_PFun] ^:= First[Values[Private`f]]
 
Last[Private`f_PFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_PFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_PFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_PFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_PFun] ^:= First[Values[Private`f]]
 
DiagonalMatrix[Private`f_PFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_PFun] ^:= IdentityMatrix[Length[Private`f]]
 
PFun[(Private`c0_)?ScalarQ, Private`d_] := PFun[{Private`c0}, Private`d]
 
PFun[Private`c0:{_, _, ___}, Private`d_] := PFun[{Private`c0}, Private`d]
 
PFun[(Private`f_)?(NotListOrPatternQ[#1] &&  !ScalarQ[#1] && 
          !ScalarQ[First[Flatten[#1]]] & ) & , Private`d_, 1] := 
    PFun[{Private`f[Private`d[[1]]]}, Private`d]
 
PFun[(Private`f_)?(NotListOrPatternQ[#1] &&  !ScalarQ[#1] && 
          !ScalarQ[First[Flatten[#1]]] & ) & , Private`d_, 
     Private`opts:OptionsPattern[]] := PFun[Private`f, Private`d, 1]
 
PFun /: PFun::usage = 
     "PFun[c0,p0,n] defines a function taking the value c0 and the point p0."
 
Private`FastTimes[Private`f$__IFun] := IFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
Private`FastTimes[Private`f$__LFun] := LFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
Private`FastTimes[Private`f$__PFun] := PFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
ConstantQ[Private`f_] := NumberQ[N[Private`f]]
 
Attributes[Private`c$] = {Temporary}
 
ArrayFunQ[(Private`f_)?FunQ] := ArrayQ[First[Values[Private`f]]]
 
ArrayFunQ[_] := False
 
ArrayFunQ /: ArrayFunQ::usage = 
     "Tests if an object is in IFun whose values are an array."
 
ToArrayFun[Private`f_] := Head[Flatten[{Private`f}][[1]]][
     ToListOfArrays[ArrayMap[Values, Private`f]], 
     Domain[First[Flatten[{Private`f}]]]]
 
Attributes[Private`if$] = {Temporary}
 
DomainIntegrate[Private`if_IFun] := Last[Integrate[Private`if]]
 
DomainIntegrate[(Private`if_LFun)?(Domain[#1][[1]] == 
        {-Infinity, Infinity} & )] := 
    FFT[Values[Private`if]*Values[LFun[If[#1 == -1., 0, MapFromCircleD[
             Private`if, #1]] & , UnitCircle, Length[Private`if]]]][[-1]]*
     (2*Pi*I)
 
DomainIntegrate[Private`if_LFun] := 
    FFT[Values[Private`if]*Values[LFun[MapFromCircleD[Private`if, #1] & , 
          UnitCircle, Length[Private`if]]]][[-1]]*(2*Pi*I)
 
DomainIntegrate[{(Private`if__)?FunQ}] := 
    Plus @@ DomainIntegrate /@ {Private`if}
 
DomainIntegrate[SingFun[Private`if_IFun, {-1/2, -1/2}]] := 
    MapFromIntervalD[Domain[Private`if], 0]*Pi*Mean[Private`if]
 
DomainIntegrate[SingFun[Private`if_IFun, {1/2, 1/2}]] := 
    First[ToChebyshevUSeries[DCT[(MapFromIntervalD[Domain[Private`if], 0]*Pi*
         Private`if)/2]]]
 
DomainIntegrate /: DomainIntegrate::usage = "DomainIntegrate[ifun] returns \
the definite integral of the function ifun over its domain."
 
MapFromCircleD[Circle[Private`a_, Private`r_], Private`z_] := Private`r
 
MapFromCircleD[Circle[Private`a_, Private`r_, Orientation -> 1], 
     Private`z_] := Private`r
 
MapFromCircleD[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := -(Private`r/Private`z^2)
 
MapFromCircleD[Line[{-Infinity, Infinity}], Private`z_] := 
    -((2*I)/(1 + Private`z)^2)
 
MapFromCircleD[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`z_] := -((2*I)/(Private`L*(1 + Private`z)^2))
 
MapFromCircleD[Line[{-Pi, Pi}], Private`z_] := 
    Derivative[1][CircleToPeriodicInterval][Private`z]
 
MapFromCircleD[Private`l_Line, Private`z_] := 
    (MapFromIntervalD[Private`l, MapFromCircle[Private`PeriodicInterval, 
         Private`z]/Pi]*MapFromCircleD[Private`PeriodicInterval, Private`z])/
     Pi
 
MapFromCircleD[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapFromIntervalD[Line[{Private`a, Private`b}], CircleToInterval[
       MapFromCircle[Circle[0, Private`r], Private`z]]]*
     Derivative[1][CircleToInterval][MapFromCircle[Circle[0, Private`r], 
       Private`z]]*MapFromCircleD[Circle[0, Private`r], Private`z]
 
MapFromCircleD[Private`f_LFun, Private`z_] := 
    MapFromCircleD[Domain[Private`f], Private`z]
 
MapFromCircleD[Curve[Private`cr_LFun], Private`z_] := 
    MapDot[Private`z^#1 & , FFT[Derivative[1][Private`cr]]]
 
MapFromCircleD /: MapFromCircleD::usage = 
     "MapFromCircleD[d,z] is the derivative of MapFromCircle[d,z]."
 
Attributes[Derivative] = {NHoldAll, ReadProtected}
 
CircleToPeriodicInterval[Private`z_] := -(I*Log[Private`z])
 
Attributes[MapFromIntervalD] = {Listable}
 
MapFromIntervalD[Line[{_?InfinityQ, _?InfinityQ}], Private`x_] := 
    Derivative[1][IntervalToRealLine][Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], 1.] := 0.
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`x_] := 
    (2*E^(I*Arg[Private`b])*Private`L)/(-1 + Private`x)^2
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`x_] := 
    -MapFromIntervalD[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      -Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 1.] := 
    0.
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`x_] := MapFromIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     -1.] := 0.
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`x_] := MapFromIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromIntervalD[Line[{Private`a_, Private`b_}], Private`x_] := 
    (Private`b - Private`a)/2
 
MapFromIntervalD[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (2*(-(Private`a*Private`L) + Private`b*Private`L))/
     (1 + Private`L - Private`z + Private`L*Private`z)^2
 
MapFromIntervalD[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`x_] := (2*E^((1*I*(Private`t0 + Private`t1))/2)*
      (-E^(I*Private`t0) + E^(I*Private`t1))*Private`r)/
     (E^((I*Private`t1)/2)*(-1 + Private`x) - E^((I*Private`t0)/2)*
        (1 + Private`x))^2
 
MapFromIntervalD[Private`f_IFun, Private`z_] := 
    MapFromIntervalD[Domain[Private`f], Private`z]
 
MapFromIntervalD[Curve[Private`cr_IFun], Private`z_] := 
    MapDot[ChebyshevT[#1 - 1, Private`z] & , DCT[Derivative[1][Private`cr]]]
 
MapFromIntervalD[Curve[Private`cr_IFun, Stretch -> Private`L_], 
     Private`z_] := MapFromIntervalD[Line[{-1, 1}, Stretch -> Private`L], 
      Private`z]*MapFromIntervalD[Curve[Private`cr], 
      MapFromInterval[Line[{-1, 1}, Stretch -> Private`L], Private`z]]
 
MapFromIntervalD /: MapFromIntervalD::usage = 
     "MapFromIntervalD[d,x] is the derivative of MapFromInterval[d,x]."
 
Attributes[IntervalToRealLine] = {Listable}
 
IntervalToRealLine[_?(NEqual[#1, 1.] & )] := Infinity
 
IntervalToRealLine[_?(NEqual[#1, -1.] & )] := -Infinity
 
IntervalToRealLine[(Private`x_)?NumberQ] := Private`x/Sqrt[1 - Private`x^2]
 
Conjugate[Arc[Private`x0_, Private`r_, {Private`t0_, Private`t1_}]] ^:= 
    Arc[Conjugate[Private`x0], Private`r, {-Private`t0, -Private`t1}]
 
Arc[Private`x0_, Private`r_, {Private`t0_, Private`t1_}]*
     (Private`c_)?NumberQ ^:= Arc[Private`c*Private`x0, Private`r, 
     {Pi - Private`t0, Pi - Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Left] /; 
     Private`t0 < Private`t1 := Arc[Private`a, Private`r, 
     {Private`t0, Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Left] := 
    Arc[Private`a, Private`r, {Private`t0 - 2*Pi, Private`t1}, Left]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Right] /; 
     Private`t0 > Private`t1 := Arc[Private`a, Private`r, 
     {Private`t0, Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Right] := 
    Arc[Private`a, Private`r, {Private`t0 + 2*Pi, Private`t1}, Right]
 
Arc[{Private`a_, Private`b_, Private`c_}] := 
    Function[Private`x0, Arc[Private`x0, Abs[Private`a - Private`x0], 
       {Arg[Private`a - Private`x0], Arg[Private`c - Private`x0]}]][
     (Det[{{Abs[Private`a]^2, Im[Private`a], 1}, {Abs[Private`b]^2, 
          Im[Private`b], 1}, {Abs[Private`c]^2, Im[Private`c], 1}}] - 
       I*Det[{{Abs[Private`a]^2, Re[Private`a], 1}, {Abs[Private`b]^2, 
           Re[Private`b], 1}, {Abs[Private`c]^2, Re[Private`c], 1}}])/
      (2*Det[{{Re[Private`a], Im[Private`a], 1}, {Re[Private`b], 
          Im[Private`b], 1}, {Re[Private`c], Im[Private`c], 1}}])]
 
Arc /: Arc::usage = "Arc[z0,r,{t0,t1}] represents the arc centred at z0 of \
radius r from argument t0 to t1."
 
DCT[Private`f:{__?ScalarQ}] := AlternatingVector[Length[Private`f]]*
     HalfFirstAndLast[FourierDCT[Private`f, 1]*
       Sqrt[2/(Length[Private`f] - 1)]]
 
DCT[Private`f:{__?VectorQ}] := ToListOfArrays[
     DCT /@ ToArrayOfLists[Private`f]]
 
DCT[Private`f:{__?MatrixQ}] := ToListOfArrays[MatrixMap[DCT, 
      ToArrayOfLists[Private`f]]]
 
DCT[(Private`f_IFun)?ArrayFunQ] := ToListOfArrays[ArrayMap[DCT, Private`f]]
 
DCT[Private`if_IFun] := DCT[Values[Private`if]]
 
DCT[Private`sf_SingFun] := DCT[First[Private`sf]]
 
DCT /: DCT::usage = "DCT[ifun] returns the Chebyshev coefficients of an IFun."
 
HalfFirstAndLast[{Private`m1_, Private`m___, Private`m2_}] := 
    {Private`m1/2, Private`m, Private`m2/2}
 
SingFun[Private`if_IFun, {Private`\[Alpha]_, Private`\[Beta]_}][
     Private`x_] := Private`if[Private`x]*
     (MapToInterval[Private`if, Private`x] + 1)^Private`\[Alpha]*
     (1 - MapToInterval[Private`if, Private`x])^Private`\[Beta]
 
Values[Private`if_SingFun] ^:= Values[First[Private`if]]
 
(Private`f$_) /@ (Private`g$_SingFun) ^:= 
    SingFun[Private`f$ /@ Values[Private`g$], Domain[Private`g$]]
 
Length[Private`if_SingFun] ^:= Length[Values[Private`if]]
 
(Private`f:SingFun[_, {Private`a_, Private`b_}]) + 
     (Private`g:SingFun[_, {Private`a_, Private`b_}]) ^:= 
    FastPlus[Private`f, Private`g]
 
(Private`f_SingFun)*(Private`g_SingFun) ^:= FastTimes[Private`f, Private`g]
 
(Private`g$_SingFun)*(Private`f$_)?ConstantQ ^:= 
    SingFun[First[Private`g$]*Private`f$, Second[Private`g$]]
 
(Private`f$_SingFun)^(Private`c$_)?ConstantQ ^:= 
    SingFun[First[Private`f$]^Private`c$, Second[Private`f$]*Private`c$]
 
Abs[Private`if$_SingFun] ^:= SingFun[Abs[First[Private`if$]], 
     Second[Private`if$]]
 
Arg[Private`if$_SingFun] ^:= SingFun[Arg[First[Private`if$]], 
     Second[Private`if$]]
 
Re[Private`if$_SingFun] ^:= SingFun[Re[First[Private`if$]], 
     Second[Private`if$]]
 
Im[Private`if$_SingFun] ^:= SingFun[Im[First[Private`if$]], 
     Second[Private`if$]]
 
Conjugate[Private`if$_SingFun] ^:= SingFun[Conjugate[First[Private`if$]], 
     Second[Private`if$]]
 
Dimensions[Private`f_SingFun] ^:= Dimensions[First[Private`f]]
 
NIntegrate[Private`sf_SingFun] ^:= DomainIntegrate[Private`sf]
 
Integrate[SingFun[Private`f_IFun, {0, 0}]] ^:= SingFun[Integrate[Private`f], 
     {0, 0}]
 
SingFun[Private`f_, (Private`d_)?DomainQ, {Private`\[Alpha]_, 
      Private`\[Beta]_}] := 
    SingFun[((RightEndpoint[Private`d] - LeftEndpoint[Private`d])^
        (Private`\[Beta] + Private`\[Alpha])*IFun[Private`f, Private`d])/
      2^(Private`\[Alpha] + Private`\[Beta]), {Private`\[Alpha], 
      Private`\[Beta]}]
 
SingFun[Private`f_, (Private`d_)?DomainQ, {Private`\[Alpha]_, 
      Private`\[Beta]_}, Private`n_Integer] := 
    SingFun[((RightEndpoint[Private`d] - LeftEndpoint[Private`d])^
        (Private`\[Beta] + Private`\[Alpha])*IFun[Private`f, Private`d, 
        Private`n])/2^(Private`\[Alpha] + Private`\[Beta]), 
     {Private`\[Alpha], Private`\[Beta]}]
 
MakeBoxes[Private`sf:SingFun[_IFun, {_, _}], FormatType_] ^:= 
    Format[ReImLinePlot[Private`sf, Sequence @@ $FunFormat], FormatType]
 
Format[Private`sf:SingFun[_IFun, {_, _}]] := ReImLinePlot[Private`sf, 
     Sequence @@ $FunFormat]
 
FastTimes[Private`f$__SingFun] := SingFun[Head[First[First[{Private`f$}]]][
      Times @@ Values /@ {Private`f$}, Domain[First[First[{Private`f$}]]]], 
     Total[Second /@ {Private`f$}]]
 
Second := #1[[2]] & 
 
DomainQ[(Private`d_)?IntervalDomainQ] := True
 
DomainQ[(Private`d_)?CircleDomainQ] := True
 
DomainQ[_?PointDomainQ] := True
 
DomainQ[_] := False
 
DomainQ /: DomainQ::usage = 
     "Test whether something is a domain (Line, Arc, Circle, Curve, etc)."
 
IntervalDomainQ[Line[{-Infinity, Infinity}]] := False
 
IntervalDomainQ[_Line] := True
 
IntervalDomainQ[_Arc] := True
 
IntervalDomainQ[Curve[_IFun]] := True
 
IntervalDomainQ[_Ellipse] := False
 
IntervalDomainQ[_] := False
 
IntervalDomainQ /: IntervalDomainQ::usage = 
     "Test whether something is a domain mapped from the unit interval."
 
CircleDomainQ[Line[{-Infinity, Infinity}]] := True
 
CircleDomainQ[_Circle] := True
 
CircleDomainQ[_Ellipse] := True
 
CircleDomainQ[Curve[_LFun]] := True
 
CircleDomainQ[_] := False
 
CircleDomainQ /: CircleDomainQ::usage = 
     "Test whether something is a domain mapped from the unit circle."
 
PointDomainQ[_Point] := True
 
PointDomainQ[_] := False
 
RightEndpoint[Line[{Private`a_, Private`b_}, ___]] := Private`b
 
RightEndpoint[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}]] := 
    N[Private`z0 + Private`r*Exp[I*Private`t1]]
 
RightEndpoint[Private`f_IFun] := RightEndpoint[Domain[Private`f]]
 
RightEndpoint[Private`if_SingFun] := RightEndpoint[First[Private`if]]
 
RightEndpoint[Private`comp_] := MapFromInterval[Private`comp, 1]
 
RightEndpoint /: RightEndpoint::usage = "RightEndpoint[d] returns the right \
endpoint of the domain d. If d is an IFun, then it is equivalent to \
RightEndpoint[Domain[d]]."
 
Attributes[MapFromInterval] = {Listable}
 
MapFromInterval[Line[{_?InfinityQ, _?InfinityQ}], Private`x_] := 
    IntervalToRealLine[Private`x]
 
MapFromInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`x_] := 
    Private`L*Exp[I*Arg[Private`b]]*IntervalToHalfLine[Private`x] + Private`a
 
MapFromInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`x_] := MapFromInterval[
     Line[{Private`b, Private`a}, Stretch -> Private`L], -Private`x]
 
MapFromInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`x_] := MapFromInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`x_] := MapFromInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromInterval[Line[{Private`a_, Private`b_}], Private`x_] := 
    (Private`b + Private`a)/2 + ((Private`b - Private`a)*Private`x)/2
 
MapFromInterval[Private`z_] := Private`z
 
MapFromInterval[Line[{Private`a_, Private`b_}, 
      Stretch -> _?(NEqual[1., #1] & )], _?InfinityQ] := Infinity
 
MapFromInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     _?InfinityQ] := (-Private`a + Private`b*Private`L)/(-1 + Private`L)
 
MapFromInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (Private`b*Private`L*(-1 - Private`z) + 
      Private`a*(-1 + Private`z))/(-1 - Private`L + Private`z - 
      Private`L*Private`z)
 
MapFromInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     _?InfinityQ] := -(E^((1*I*(Private`t0 + Private`t1))/2)*Private`r) + 
     Private`z0
 
MapFromInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`x_] := (-(E^((1*I*(Private`t0 + 2*Private`t1))/2)*Private`r*
        (1 + Private`x)) - E^((I*Private`t0)/2)*(1 + Private`x)*Private`z0 + 
      E^((I*Private`t1)/2)*(-1 + Private`x)*(E^(I*Private`t0)*Private`r + 
        Private`z0))/(E^((I*Private`t1)/2)*(-1 + Private`x) - 
      E^((I*Private`t0)/2)*(1 + Private`x))
 
MapFromInterval[Private`f_IFun, Private`z_] := 
    MapFromInterval[Domain[Private`f], Private`z]
 
MapFromInterval[Curve[Private`cr_IFun], Private`z_] := 
    MapDot[ChebyshevT[#1 - 1, Private`z] & , DCT[Private`cr]]
 
MapFromInterval[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapFromInterval[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapFromInterval[Curve[Private`cr], MapFromInterval[
      Line[{-1, 1}, Stretch -> Private`L], Private`z]]
 
MapFromInterval /: MapFromInterval::usage = "MapFromInterval[d,x] maps the \
point x via the conformal map that maps the unit interval to the domain d. If \
d is an IFun, then it is equivalent to MapFromInterval[Domain[d],x]."
 
Attributes[IntervalToHalfLine] = {Listable}
 
IntervalToHalfLine[_?(NEqual[#1, 1.] & )] := Infinity
 
IntervalToHalfLine[_?InfinityQ] := -1.
 
IntervalToHalfLine[Private`x_] := (Private`x + 1)/(1 - Private`x)
 
LeftEndpoint[Line[{Private`a_, Private`b_}, ___]] := Private`a
 
LeftEndpoint[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}]] := 
    N[Private`z0 + Private`r*Exp[I*Private`t0]]
 
LeftEndpoint[Private`f_IFun] := LeftEndpoint[Domain[Private`f]]
 
LeftEndpoint[Private`if_SingFun] := LeftEndpoint[First[Private`if]]
 
LeftEndpoint[Private`comp_] := MapFromInterval[Private`comp, -1]
 
LeftEndpoint /: LeftEndpoint::usage = "LeftEndpoint[d] returns the left \
endpoint of the domain d. If d is an IFun, then it is equivalent to \
LeftEndpoint[Domain[d]]."
 
ReImLinePlot[(Private`f_)?VectorFunQ, Private`opts___] := 
    MatrixForm[{ArrayMap[ReImLinePlot[#1, Private`opts] & , 
       ToArrayOfFuns[Private`f]]}]
 
ReImLinePlot[(Private`f_)?ArrayFunQ, Private`opts___] := 
    MatrixForm[ArrayMap[ReImLinePlot[#1, Private`opts] & , 
      ToArrayOfFuns[Private`f]]]
 
ReImLinePlot[Private`f_, Private`opts___] := 
    ListLinePlot[{Private`PlotPointValueList[Re[Private`f]], 
      Private`PlotPointValueList[Im[Private`f]]}, Private`opts]
 
Private`PlotPointValueList[(Private`f_)?FunQ] := 
    Thread[{Private`FiniteRealPoints[Private`f], FiniteValues[Private`f]}]
 
Private`PlotPointValueList[SingFun[Private`f_IFun, {Private`\[Alpha]_, 
       Private`\[Beta]_}]] := Private`PlotPointValueList[
     Fun[Piecewise[{{0, (NEqual[#1, RightEndpoint[Private`f]] && 
             Private`\[Beta] != 0) || (NEqual[#1, LeftEndpoint[Private`f]] && 
             Private`\[Alpha] != 0)}, 
          {1, (NEqual[#1, RightEndpoint[Private`f]] && Private`\[Beta] == 
              0) || (NEqual[#1, LeftEndpoint[Private`f]] && 
             Private`\[Alpha] == 0)}, {(MapToInterval[Private`f, #1] + 1)^
             Private`\[Alpha]*(1 - MapToInterval[Private`f, #1])^
             Private`\[Beta], True}}] & , Domain[Private`f], 100]*
      SetLength[Private`f, 100]]
 
Private`FiniteRealPoints[Private`if:IFun[_, Line[{-Infinity, Infinity}]]] := 
    FinitePoints[Private`if]
 
Private`FiniteRealPoints[Private`if_IFun] /; 
     NEqual[Re[LeftEndpoint[Private`if]], Re[RightEndpoint[Private`if]]] := 
    Im[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[Private`if_LFun] := Re[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[Private`if_PFun] := Re[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[(Private`if_)?FunQ] := Re[FinitePoints[Private`if]]
 
FinitePoints[(Private`if_IFun)?(LeftEndpointInfinityQ[#1] && 
        RightEndpointInfinityQ[#1] & )] := 
    Rest[Most[IntervalPoints[Private`if]]]
 
FinitePoints[(Private`if_IFun)?LeftEndpointInfinityQ] := 
    Rest[IntervalPoints[Private`if]]
 
FinitePoints[(Private`if_IFun)?RightEndpointInfinityQ] := 
    Most[IntervalPoints[Private`if]]
 
FinitePoints[Private`if_IFun] := IntervalPoints[Private`if]
 
FinitePoints[Private`if:LFun[_, Line[{-Infinity, Infinity}, ___]]] := 
    Rest[Points[Private`if]]
 
FinitePoints[Private`if_LFun] := Points[Private`if]
 
FinitePoints[Private`if_PFun] := Points[Private`if]
 
FinitePoints[Private`l:{__?FunQ}] := Flatten[FinitePoints /@ Private`l]
 
FinitePoints[Private`d_, Private`n_] := Points[Private`d, Private`n]
 
LeftEndpointInfinityQ[Line[{_?InfinityQ, _}, ___]] := True
 
LeftEndpointInfinityQ[Private`f_IFun] := LeftEndpointInfinityQ[
     Domain[Private`f]]
 
LeftEndpointInfinityQ[_] := False
 
LeftEndpointInfinityQ /: LeftEndpointInfinityQ::usage = 
     "LeftEndpointInfinityQ[d] tests if a domain's left endpoint is \
unbounded."
 
RightEndpointInfinityQ[Line[{_, _?InfinityQ}, ___]] := True
 
RightEndpointInfinityQ[Private`f_IFun] := RightEndpointInfinityQ[
     Domain[Private`f]]
 
RightEndpointInfinityQ[_] := False
 
RightEndpointInfinityQ /: RightEndpointInfinityQ::usage = 
     "RightEndpointInfinityQ[d] tests if a domain's right endpoint is \
unbounded."
 
IntervalPoints[Private`d_, Private`n_] := MapFromInterval[Private`d, 
     NChebyshevLobattoPoints[Private`n]]
 
IntervalPoints[Private`f_IFun] := Points[Private`f]
 
Points[(Private`d_)?IntervalDomainQ, Private`n_] := 
    IntervalPoints[Private`d, Private`n]
 
Points[Private`if_IFun] := IntervalPoints[Domain[Private`if], 
     Length[Private`if]]
 
Points[(Private`d_)?CircleDomainQ, Private`n_] := MapFromCircle[Private`d, 
     Private`ComplexCirclePoints[Private`n]]
 
Points[Private`lf_LFun] := MapFromCircle[Domain[Private`lf], 
     Points[UnitCircle, Length[Private`lf]]]
 
Points[Point[Private`z0_], 1] := {Private`z0}
 
Points[Private`if_PFun] := Points[Domain[Private`if], Length[Private`if]]
 
Points[Private`l:{__?FunQ}] := Flatten[Points /@ Private`l]
 
Points[Private`if_SingFun] := Points[Domain[Private`if], Length[Private`if]]
 
Points /: Points::usage = "Points[ifun] returns the the mapped \
Chebyshev\[Dash]Lobatto points.  Points[d,n] returns n mapped \
Chebyshev\[Dash]Lobatto points over a domain d."
 
Attributes[MapFromCircle] = {Listable}
 
MapFromCircle[Circle[Private`a_, Private`r_], Private`z_] := 
    Private`r*Private`z + Private`a
 
MapFromCircle[Circle[Private`a_, Private`r_, Orientation -> 1], 
     Private`z_] := Private`r*Private`z + Private`a
 
MapFromCircle[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := Private`r/Private`z + Private`a
 
MapFromCircle[Line[{-Infinity, Infinity}], _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}], Private`z_] := 
    (-(I*Private`z) + I)/(Private`z + 1)
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`z_] := -((I*(-1 + Private`z))/(Private`L*(1 + Private`z)))
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(-1 + Private`z))/(Private`L*(1 + Private`z))
 
MapFromCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(I*(-1 + Private`z)))/(Private`L*(1 + Private`z))
 
MapFromCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(I*(-1 + 1/Private`z)))/(Private`L*(1 + 1/Private`z))
 
MapFromCircle[Line[{-Pi, Pi}], Private`z_] := CircleToPeriodicInterval[
     Private`z]
 
MapFromCircle[Private`l_Line, Private`z_] := MapFromInterval[Private`l, 
     MapFromCircle[Private`PeriodicInterval, Private`z]/Pi]
 
MapFromCircle[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapFromInterval[Line[{Private`a, Private`b}], 
     CircleToInterval[MapFromCircle[Circle[0, Private`r], Private`z]]]
 
MapFromCircle[Private`f_LFun, Private`z_] := MapFromCircle[Domain[Private`f], 
     Private`z]
 
MapFromCircle[Curve[Private`cr_LFun], Private`z_] := 
    MapDot[Private`z^#1 & , FFT[Private`cr]]
 
MapFromCircle[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapFromCircle[Curve[Private`cr_], (Private`z_)?ZeroQ] := 0
 
MapFromCircle /: MapFromCircle::usage = "MapToCircle[d,z] maps z via the \
conformal map from the unit circle to the domain d."
 
CircleToInterval[Private`z_] := (1*(Private`z + 1/Private`z))/2
 
CircleToInterval /: CircleToInterval::usage = 
     "CircleToInterval[z] conformally maps the unit circle to the unit \
interval."
 
ZeroQ[Private`f_] := Private`f == 0
 
Private`ComplexCirclePoints[Private`n_] := Exp[I*Pi*LeftEvenPoints[Private`n]]
 
LeftEvenPoints[Private`n_] := Range[-1, (Private`n - 1)/Private`n, 
     2/Private`n]
 
LeftEvenPoints[Private`n_, Private`a_, Private`b_] := 
    Private`a + ((Private`b - Private`a)*(1 + LeftEvenPoints[Private`n]))/2
 
LeftEvenPoints /: LeftEvenPoints::usage = 
     "Evenly spaced points on the unit interval."
 
UnitCircle = Circle[0, 1]
 
UnitCircle /: UnitCircle::usage = "The unit circle Circle[0.,1.]."
 
FiniteValues[(Private`if_IFun)?(LeftEndpointInfinityQ[#1] && 
        RightEndpointInfinityQ[#1] & )] := Rest[Most[Values[Private`if]]]
 
FiniteValues[(Private`if_IFun)?LeftEndpointInfinityQ] := 
    Rest[Values[Private`if]]
 
FiniteValues[(Private`if_IFun)?RightEndpointInfinityQ] := 
    Most[Values[Private`if]]
 
FiniteValues[Private`if_IFun] := Values[Private`if]
 
FiniteValues[Private`if_LFun] := 
    Last /@ Select[Thread[{Points[Private`if], Values[Private`if]}], 
       !InfinityQ[First[#1]] & ]
 
FiniteValues[Private`pf_PFun] := Values[Private`pf]
 
Fun[(Private`f_)?NotListOrPatternQ, Private`l:Line[{_, _}, ___], 
     Private`opts___] := IFun[Private`f, Private`l, Private`opts]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`n_List] := 
    (If[Length[#1] == 1, #1[[1]], #1] & )[
     (IFun[Private`f, Line[#1[[1]], Sequence @@ 
          If[Or @@ InfinityQ /@ #1[[1]], {Private`Lopts}, {}]], 
        #1[[2]]] & ) /@ Thread[{Partition[Private`l, 2, 1], Private`n}]]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`n_Integer] := 
    Fun[Private`f, Line[Private`l, Private`Lopts], 
     Private`n*OneVector[Length[Private`l] - 1]]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`opts:OptionsPattern[]] := 
    (If[Length[#1] == 1, #1[[1]], #1] & )[
     (IFun[Private`f, Line[#1, Sequence @@ If[Or @@ InfinityQ /@ #1, 
           {Private`Lopts}, {}]], Private`opts] & ) /@ 
      Partition[Private`l, 2, 1]]
 
Fun[Private`f_, (Private`d_)?IntervalDomainQ, Private`opts___] := 
    IFun[Private`f, Private`d, Private`opts]
 
Fun[Private`a_] := Fun[Private`a, UnitInterval]
 
Fun[Private`f_, (Private`d_)?CircleDomainQ, Private`opts___] := 
    LFun[Private`f, Private`d, Private`opts]
 
Fun[Private`f_, (Private`d_)?PointDomainQ, Private`opts___] := 
    PFun[Private`f, Private`d, Private`opts]
 
Fun[Private`f_, Private`l_List, Private`n_List] := 
    Flatten[(Fun[Private`f, #1[[1]], #1[[2]]] & ) /@ 
      Thread[{Private`l, Private`n}]]
 
Fun[Private`f_, Private`l_List, Private`opts___] := 
    Flatten[(Fun[Private`f, #1, Private`opts] & ) /@ Private`l]
 
Fun /: Fun::usage = 
     "\nDecides between IFun and LFun, and allows Line[{a,b,c}]"
 
NotListOrPatternQ[Private`f_] :=  !ListQ[Private`f] && 
      !Head[Private`f] === Pattern &&  !Head[Private`f] === Blank
 
OneVector[Private`n_] := Table[1, {Private`n}]
 
OneVector /: OneVector::usage = 
     "OneVector[n] constructs a vector of length n of all ones."
 
UnitInterval = Line[{-1, 1}]
 
UnitInterval /: UnitInterval::usage = "The unit interval Line[{-1.,1.}]."
 
SetLength[Private`if_IFun, Private`n_] := 
    IFun[InverseDCT[PadRight[DCT[Private`if], Private`n]], Domain[Private`if]]
 
SetLength[Private`if_LFun, (Private`n_)?OddQ] := 
    LFun[InverseFFT[SetIndexRange[FFT[Private`if], {(1 - Private`n)/2, 
        (Private`n - 1)/2}]], Domain[Private`if]]
 
SetLength[Private`if_LFun, (Private`n_)?EvenQ] := 
    LFun[InverseFFT[SetIndexRange[FFT[Private`if], {-(Private`n/2), 
        Private`n/2 - 1}]], Domain[Private`if]]
 
InverseDCT[Private`f:{__?ScalarQ}] := 
    Reverse[((Length[Private`f] - 1)*AlternatingVector[Length[Private`f]]*
       DoubleFirstAndLast[DCT[DoubleFirstAndLast[Private`f]]])/2]
 
InverseDCT[Private`f:{__?VectorQ}] := ToListOfArrays[
     InverseDCT /@ ToArrayOfLists[Private`f]]
 
InverseDCT[Private`f:{__?MatrixQ}] := ToListOfArrays[
     MatrixMap[InverseDCT, ToArrayOfLists[Private`f]]]
 
DoubleFirstAndLast[{Private`m1_, Private`m___, Private`m2_}] := 
    {Private`m1*2, Private`m, Private`m2*2}
 
InverseFFT[Private`c:ShiftList[{__?ScalarQ}, _]] := 
    Module[{Private`scale, Private`cc, Private`cf, Private`j, Private`n}, 
     Private`n = Length[Private`c]; Private`scale = 
       First[Fourier[(1 & ) /@ LeftEvenPoints[Private`n]]]; 
      InverseFourier[-(Reverse[AlternatingVector[Private`n]]*Private`scale*
         If[EvenQ[Private`n], RotateLeft[Reverse[ToList[Private`c]], 
           (Private`n - 2)/2], RotateLeft[Reverse[
            ToList[ShiftList[(-1)^Private`n*OneVector[(Private`n - 1)/2], 
               Join[{(-1)^Private`n}, OneVector[(Private`n - 1)/2]]]*
              Private`c]], (Private`n - 1)/2]])]]
 
InverseFFT[Private`sl:ShiftList[{__?ArrayQ}, _]] := 
    ToListOfArrays[ArrayMap[InverseFFT, ToArrayOfShiftLists[Private`sl]]]
 
InverseFFT /: InverseFFT::usage = "Returns values that a ShiftList of Laurent \
coefficients would take on the unit circle."
 
SetIndexRange[Private`sl_ShiftList, Private`ind_] := 
    Module[{Private`sl2}, Private`sl2 = PadLeft[Private`sl, 
        Length[Private`sl] + FirstIndex[Private`sl] - First[Private`ind]]; 
      PadRight[Private`sl2, Length[Private`sl2] + Last[Private`ind] - 
        LastIndex[Private`sl]]]
 
SetIndexRange[Private`sm_ShiftMatrix, {Private`i_, Private`j_}, 
     {Private`m_, Private`n_}] := PadRight[PadLeft[Private`sm, 
      {Private`i, Private`m}], {Private`j, Private`n}]
 
ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, Private`jind_}][[
     Private`i_,Private`j_]] ^:= Private`ls[[Private`fixind[Private`i, 
      Private`iind],Private`fixind[Private`j, Private`jind]]]
 
ShiftMatrix /: ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
        Private`jind_}][[Private`i_Integer]] := 
     ShiftList[Private`ls[[Private`fixind[Private`i, Private`iind]]], 
      Private`jind]
 
(Private`f_) /@ ShiftMatrix[(Private`ls_)?MatrixQ, 
      {Private`iind_, Private`jind_}] ^:= 
    (Private`f[ShiftList[#1, Private`jind]] & ) /@ Private`ls
 
Transpose[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] ^:= ShiftMatrix[Transpose[Private`ls], 
     {Private`jind, Private`iind}]
 
Inverse[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] ^:= ShiftMatrix[Inverse[Private`ls], 
     {Private`jind, Private`iind}]
 
Normal[Private`sl_ShiftMatrix] ^:= ToArray[Private`sl]
 
Dimensions[ShiftMatrix[(Private`ls_)?MatrixQ, {_, _}]] ^:= 
    Dimensions[Private`ls]
 
ShiftMatrix /: PadRight[Private`sm_ShiftMatrix, {Private`m_, Private`n_}] := 
     ShiftMatrix[PadRight[ToArray[Private`sm], 
       {Private`m + RowIndex[Private`sm], Private`n + 
         ColumnIndex[Private`sm]}], {RowIndex[Private`sm], 
       ColumnIndex[Private`sm]}]
 
ShiftMatrix /: PadLeft[Private`sm_ShiftMatrix, {Private`m_, Private`n_}] := 
     ShiftMatrix[PadLeft[ToArray[Private`sm], 
       {Length[ToArray[Private`sm]] - RowIndex[Private`sm] + 1 - Private`m, 
        Second[Dimensions[ToArray[Private`sm]]] - ColumnIndex[Private`sm] + 
         1 - Private`n}], {1 - Private`m, 1 - Private`n}]
 
ShiftMatrix /: (Private`sm_ShiftMatrix) . (Private`sl_ShiftList) := 
     ShiftList[ToArray[Private`sm] . ToList[Private`sl], 
      RangeIndex[Private`sm]]
 
ShiftMatrix /: (Private`sl_ShiftList) . (Private`sm_ShiftMatrix) := 
     ShiftList[ToList[Private`sl] . ToArray[Private`sm], 
      ColumnIndex[Private`sm]]
 
(Private`sm_ShiftMatrix) . (Private`sm2_ShiftMatrix) ^:= 
    ShiftMatrix[ToArray[Private`sm] . ToArray[Private`sm2], 
     {RangeIndex[Private`sm], DomainIndex[Private`sm2]}]
 
(Private`sm_ShiftMatrix) + (Private`sm2_ShiftMatrix) ^:= 
    ShiftMatrix[ToArray[Private`sm] + ToArray[Private`sm2], 
     {RangeIndex[Private`sm], DomainIndex[Private`sm2]}]
 
(Private`sm_ShiftMatrix)*(Private`c_)?NumberQ ^:= 
    ShiftMatrix[Private`c*ToArray[Private`sm], {RangeIndex[Private`sm], 
      DomainIndex[Private`sm]}]
 
ShiftMatrix /: LinearSolve[Private`sm_ShiftMatrix, Private`sl_ShiftList] := 
     ShiftList[LinearSolve[ToArray[Private`sm], ToList[Private`sl]], 
      DomainIndex[Private`sm]]
 
Re[ShiftMatrix[(Private`ls_)?MatrixQ, Private`ind_]] ^:= 
    ShiftMatrix[Re[Private`ls], Private`ind]
 
Im[ShiftMatrix[(Private`ls_)?MatrixQ, Private`ind_]] ^:= 
    ShiftMatrix[Im[Private`ls], Private`ind]
 
ShiftMatrix[{(Private`A_)?MatrixQ, (Private`B_)?MatrixQ}] := 
    ShiftMatrix[Private`RightJoin[Private`A, Private`B], 
     {1, Dimensions[Private`A][[2]] + 1}]
 
MakeBoxes[Private`sm:ShiftMatrix[_?MatrixQ, {_Integer, _Integer}], 
     FormatType_] ^:= Format[MatrixForm[Module[{Private`i, Private`j}, 
       Table[If[Private`i == 0 || Private`j == 0, 
         Style[Private`sm[[Private`i,Private`j]], Bold], 
         Private`sm[[Private`i,Private`j]]], {Private`i, 
         RowIndexRange[Private`sm][[1]], RowIndexRange[Private`sm][[2]]}, 
        {Private`j, ColumnIndexRange[Private`sm][[1]], 
         ColumnIndexRange[Private`sm][[2]]}]]], FormatType]
 
Format[Private`sm:ShiftMatrix[_?MatrixQ, {_Integer, _Integer}]] := 
    MatrixForm[Module[{Private`i, Private`j}, 
      Table[If[Private`i == 0 || Private`j == 0, 
        Style[Private`sm[[Private`i,Private`j]], Bold], 
        Private`sm[[Private`i,Private`j]]], {Private`i, 
        RowIndexRange[Private`sm][[1]], RowIndexRange[Private`sm][[2]]}, 
       {Private`j, ColumnIndexRange[Private`sm][[1]], 
        ColumnIndexRange[Private`sm][[2]]}]]]
 
ToArray[ShiftMatrix[Private`ls_, {_, _}]] := Private`ls
 
RowIndex[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] := Private`iind
 
ColumnIndex[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] := Private`jind
 
RangeIndex := RowIndex
 
DomainIndex := ColumnIndex
 
RowIndexRange[Private`l_ShiftMatrix] := {1 - RowIndex[Private`l], 
     Dimensions[Private`l][[1]] - RowIndex[Private`l]}
 
ColumnIndexRange[Private`l_ShiftMatrix] := {1 - ColumnIndex[Private`l], 
     Dimensions[Private`l][[2]] - ColumnIndex[Private`l]}
 
$FunFormat = {ImageSize -> Small}
 
ToChebyshevUSeries[Private`ts:{_}] := Private`ts
 
ToChebyshevUSeries[Private`ts_] := DoubleFirst[Private`ts]/2 - 
     PadRight[Rest[Rest[Private`ts]]/2, Length[Private`ts]]
 
DoubleFirst[{Private`m1_, Private`m___}] := {2*Private`m1, Private`m}
 
ListFunQ[(Private`f_)?FunQ] := ListQ[First[Values[Private`f]]]
 
ListFunQ[_] := False
 
ListFunQ /: ListFunQ::usage = 
     "Tests if an object is in IFun whose values are a list."
 
MapToCircleD[Circle[Private`a_, Private`r_], Private`z_] := 1/Private`r
 
MapToCircleD[Circle[Private`a_, Private`r_, Orientation -> 1], Private`z_] := 
    1/Private`r
 
MapToCircleD[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := -(Private`r/(Private`z - Private`a)^2)
 
MapToCircleD[Line[{-Infinity, Infinity}], Private`t_] := 
    -((2*I)/(I + Private`t)^2)
 
MapToCircleD[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`t_] := -((2*I*Private`L)/(I + Private`L*Private`t)^2)
 
MapToCircleD[Line[{-Pi, Pi}], Private`z_] := I*Exp[I*Private`z]
 
MapToCircleD[Private`l_Line, Private`z_] := 
    MapToCircleD[Private`PeriodicInterval, 
      MapToInterval[Private`l, Private`z]*Pi]*MapToIntervalD[Private`l, 
      Private`z]*Pi
 
MapToCircleD[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapToCircleD[Circle[0, Private`r], IntervalToInnerCircle[
       MapToInterval[Line[{Private`a, Private`b}], Private`z]]]*
     Derivative[1][IntervalToInnerCircle][MapToInterval[
       Line[{Private`a, Private`b}], Private`z]]*
     MapToIntervalD[Line[{Private`a, Private`b}], Private`z]
 
MapToCircleD[Private`f_LFun, Private`z_] := MapToCircleD[Domain[Private`f], 
     Private`z]
 
MapToCircleD[Private`cr:Curve[_], Private`z_] := 
    1/MapFromCircleD[Private`cr, MapToCircle[Private`cr, Private`z]]
 
MapToCircleD /: MapToCircleD::usage = 
     "MapToCircleD[d,z] is the derivative of MapToCircle[d,z]."
 
Attributes[MapToIntervalD] = {Listable}
 
MapToIntervalD[Line[{_?InfinityQ, _?InfinityQ}], Private`y_] := 
    Derivative[1][RealLineToInterval][Private`y]
 
MapToIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`z_] := 
    (2*E^(I*Arg[Private`b])*Private`L)/
     (-Private`a + E^(I*Arg[Private`b])*Private`L + Private`z)^2
 
MapToIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`z_] := 
    -MapToIntervalD[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      Private`z]
 
MapToIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`z_] := MapToIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`z_] := MapToIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToIntervalD[Line[{Private`a_, Private`b_}], Private`x_] := 
    -(2/(Private`a - Private`b))
 
MapToIntervalD[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := -((2*(Private`a*Private`L - Private`b*Private`L))/
      (Private`a - Private`b*Private`L - Private`z + Private`L*Private`z)^2)
 
MapToIntervalD[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`z_] := (2*E^((I*Private`t0)/2)*(E^(I*Private`t1) + 
       E^((1*I*(Private`t0 + Private`t1))/2))*Private`r)/
     ((-E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
      (E^((1*I*(Private`t0 + Private`t1))/2)*Private`r + Private`z - 
        Private`z0)^2)
 
MapToIntervalD[Private`f_IFun, Private`z_] := 
    MapToIntervalD[Domain[Private`f], Private`z]
 
MapToIntervalD[Private`cr:Curve[_], Private`z_] := 
    1/MapFromIntervalD[Private`cr, MapToInterval[Private`cr, Private`z]]
 
MapToIntervalD[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapToIntervalD[Line[{-1, 1}, Stretch -> Private`L], 
      MapToInterval[Curve[Private`cr], Private`z]]/
     MapFromIntervalD[Curve[Private`cr], MapToInterval[Curve[Private`cr], 
       Private`z]]
 
MapToIntervalD /: MapToIntervalD::usage = 
     "MapToIntervalD[d,x] is the derivative of MapToInterval[d,x]."
 
ShiftLeft[Private`f_ShiftList] := ShiftList[ToList[Private`f], 
     Index[Private`f] + 1]
 
ShiftLeft[Private`f_ShiftList, Private`d_] := ShiftList[ToList[Private`f], 
     Index[Private`f] + Private`d]
 
ShiftLeft[Private`l_List] := Rest[Private`l]
 
ShiftLeft[Private`l_List, Private`k_] := Private`l[[Private`k + 1 ;; All]]
 
MapOuter[Private`m_, Private`lst_] := MapIndexed[
     SDot[Private`m[First[#2]], #1] & , Private`lst]
 
SDot[Private`f_List, Private`g_List] := Private`f . Private`g
 
SDot[Private`f_, Private`g_] := Private`f*Private`g
 
BoundedIntegrate[(Private`lf_LFun)?UnitCircleFunQ] := 
    LFun[InverseFFT[MakeFFTIndexRange[MapOuter[If[ZeroQ[#1], 0, 1/#1] & , 
        ShiftRight[FFT[Private`lf]]]]], Domain[Private`lf]]
 
BoundedIntegrate[Private`lf_LFun] := SetDomain[BoundedIntegrate[
      ToUnitCircle[Private`lf]*
       LFun[Piecewise[{{0, InfinityQ[MapFromCircle[Private`lf, #1]]}, 
           {MapFromCircleD[Private`lf, #1], True}}] & , UnitCircle, 
        Length[Private`lf]]], Domain[Private`lf]]
 
BoundedIntegrate /: BoundedIntegrate::usage = 
     "BoundedIntegrate[lf] integrates an LFun with its -1 coefficient \
removed"
 
UnitCircleFunQ[Private`f_LFun] := N[Domain[Private`f]] == N[UnitCircle]
 
UnitCircleFunQ[_] := False
 
UnitCircleFunQ /: UnitCircleFunQ::usage = 
     "Tests whether an object is an LFun whose domain is the unit circle."
 
MakeFFTIndexRange[Private`sl_ShiftList] := SetIndexRange[Private`sl, 
     {-1, 1}*Max[Abs[IndexRange[Private`sl]]]]
 
ShiftRight[Private`f_ShiftList] := ShiftList[ToList[Private`f], 
     Index[Private`f] - 1]
 
ShiftRight[Private`f_ShiftList, Private`d_] := ShiftList[ToList[Private`f], 
     Index[Private`f] - Private`d]
 
ShiftRight[Private`l_List] := Join[{0}, Most[Private`l]]
 
SetDomain[(Private`f_)?FunQ, (Private`d_)?FunQ] := 
    SetDomain[Private`f, Domain[Private`d]]
 
SetDomain[(Private`f_)?FunQ, (Private`d_)?DomainQ] := 
    Head[Private`f][Values[Private`f], Private`d]
 
SetDomain[Private`f_List, Private`d_List] := (SetDomain @@ #1 & ) /@ 
     Thread[{Private`f, Private`d}]
 
SetDomain[Private`op_Private`FunValueListOperator, Private`d_] := 
    Private`FunValueListOperator[Private`op[[1]], SetDomain[Private`op[[2]], 
      Private`d]]
 
SetDomain /: SetDomain::usage = 
     "SetDomain[f,d] changes the domain of the Fun (or List of Funs) f to d"
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?ScalarFunQ}] := FromValueList[Private`g, 
     Private`mat . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?VectorFunQ}] := FromValueList[(({0, 0} & ) /@ #1 & ) /@ 
      Private`g, ScalarToVectorMatrix[Private`mat] . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?MatrixFunQ}] := FromValueList[
     (({{0, 0}, {0, 0}} & ) /@ #1 & ) /@ Private`g, 
     ScalarToMatrixMatrix[Private`mat] . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_][Private`f_] := 
    Private`FunValueListOperator[Private`mat, Private`f][Private`f]
 
FromValueList[(Private`f_IFun)?ScalarFunQ, Private`ls_] := 
    ZeroAtInfinityIFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_IFun)?VectorFunQ, Private`ls_] := 
    ToArrayFun[(ZeroAtInfinityIFun[#1, Domain[Private`f]] & ) /@ 
      Partition[Private`ls, FiniteLength[Private`f]]]
 
FromValueList[(Private`f_IFun)?MatrixFunQ, Private`ls_] := 
    ToArrayFun[MatrixMap[ZeroAtInfinityIFun[#1, Domain[Private`f]] & , 
      PartitionList[Partition[Private`ls, FiniteLength[Private`f]], 
       Dimensions[Private`f]]]]
 
FromValueList[(Private`f_LFun)?ScalarFunQ, Private`ls_] := 
    ZeroAtInfinityLFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_LFun)?MatrixFunQ, Private`ls_] := 
    ToArrayFun[MatrixMap[ZeroAtInfinityLFun[#1, Domain[Private`f]] & , 
      PartitionList[Partition[Private`ls, FiniteLength[Private`f]], 
       Dimensions[Private`f]]]]
 
FromValueList[(Private`f_LFun)?VectorFunQ, Private`ls_] := 
    ToArrayFun[(ZeroAtInfinityLFun[#1, Domain[Private`f]] & ) /@ 
      Partition[Private`ls, FiniteLength[Private`f]]]
 
FromValueList[(Private`f_PFun)?ScalarFunQ, Private`ls_] := 
    PFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_PFun)?MatrixFunQ, Private`ls_] := 
    PFun[{PartitionList[Private`ls, Dimensions[Private`f]]}, 
     Domain[Private`f]]
 
FromValueList[(Private`f_PFun)?VectorFunQ, Private`ls_] := 
    PFun[{Private`ls}, Domain[Private`f]]
 
FromValueList[(Private`GI_List)?(VectorFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, ToListOfArrays /@ Thread[PartitionList[
          PartitionList[Private`ls, Flatten[ArrayMap[FiniteLength, 
             ToArrayOfListOfFuns[Private`GI]]]], Length /@ 
           ToArrayOfLists[ToArrayOfFuns /@ Private`GI]]]}]
 
FromValueList[(Private`GI_List)?(MatrixFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, ToListOfMatrices /@ ToListOfMatrices[
         PartitionList[Partition[PartitionList[Private`ls, 
            Flatten[ArrayMap[FiniteLength, ToArrayOfListOfFuns[
               Private`GI]]]], Length[Private`GI]], Dimensions[
           First[Private`GI]]]]}]
 
FromValueList[(Private`GI_List)?(ScalarFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, PartitionList[Private`ls, FiniteLength /@ 
         Private`GI]}]
 
ZeroAtInfinityIFun[Private`ls_List, (Private`d_)?LeftEndpointInfinityQ] := 
    IFun[Join[{0*Private`ls[[1]]}, Private`ls], Private`d]
 
ZeroAtInfinityIFun[Private`ls_List, (Private`d_)?RightEndpointInfinityQ] := 
    IFun[Join[Private`ls, {0*Private`ls[[1]]}], Private`d]
 
ZeroAtInfinityIFun[Private`ls_List, Private`d_] := IFun[Private`ls, Private`d]
 
ZeroAtInfinityIFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := IFun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityIFun /: ZeroAtInfinityIFun::usage = 
     "Constructs a Fun with the default value of zero at infinity"
 
FiniteLength[Private`f_] := Length[FinitePoints[Private`f]]
 
PartitionList[Private`l_, {}] := {}
 
PartitionList[Private`l_, (Private`d_)?VectorQ] := 
    Join[{Private`l[[1 ;; First[Private`d]]]}, 
     PartitionList[Private`l[[First[Private`d] + 1 ;; -1]], Rest[Private`d]]]
 
PartitionList[Private`l_, (Private`d_)?MatrixQ] := 
    PartitionList[PartitionList[Private`l, Flatten[Private`d]], 
     Length /@ Private`d]
 
ZeroAtInfinityLFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := LFun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityLFun[Private`f_List, Line[{-Infinity, Infinity}]] := 
    LFun[Join[{0*Private`f[[1]]}, Private`f], RealLine]
 
ZeroAtInfinityLFun[Private`f_List, Private`d_] := LFun[Private`f, Private`d]
 
ZeroAtInfinityLFun /: ZeroAtInfinityLFun::usage = 
     "Constructs a LFun with the default value of zero at infinity"
 
RealLine = Line[{-Infinity, Infinity}]
 
RealLine /: RealLine::usage = "The real line Line[{-\[Infinity],\[Infinity]}]"
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?IntervalDomainQ] := 
    ZeroAtInfinityIFun[Private`f, Private`d]
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?CircleDomainQ] := 
    ZeroAtInfinityLFun[Private`f, Private`d]
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?PointDomainQ] := 
    PFun[Private`f, Private`d]
 
ZeroAtInfinityFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := Fun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityFun /: ZeroAtInfinityFun::usage = 
     "Constructs a Fun with the default value of zero at infinity"
 
ToArrayOfListOfFuns[Private`f_List] := ToArrayOfLists[
     ToArrayOfFuns /@ Private`f]
 
ToValueList[Private`GI_List] := Flatten[(ArrayMap[FiniteValues, #1] & ) /@ 
      ToArrayOfLists[ToArrayOfFuns /@ Private`GI]]
 
ToValueList[(Private`f_)?FunQ] := Flatten[ArrayMap[FiniteValues, 
      ToArrayOfFuns[Private`f]]]
 
ScalarToVectorMatrix := BlockDiagonalMatrix[{#1, #1}] & 
 
BlockDiagonalMatrix[Private`Al_List] := 
    Module[{Private`Asp, Private`k, Private`j, Private`dim, Private`sete}, 
     Private`dim[(Private`al_)?MatrixQ] := Dimensions[Private`al]; 
      Private`dim[(Private`al_)?VectorQ] := {Length[Private`al], 1}; 
      Private`dim[Private`al_] := {1, 1}; Private`Asp = 
       SparseZeroMatrix @@ Total[Private`dim /@ Private`Al]; 
      {Private`k, Private`j} = {0, 0}; Private`sete[(Private`A_)?MatrixQ] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 
            Dimensions[Private`A][[1]]),Private`j + 1 ;; 
          (Private`j = Private`j + Dimensions[Private`A][[2]])]] = Private`A; 
      Private`sete[(Private`A_)?VectorQ] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 
            Length[Private`A]),Private`j + 1 ;; (Private`j = 
           Private`j + 1)]] = Private`A; Private`sete[Private`A_] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 1),
         Private`j + 1 ;; (Private`j = Private`j + 1)]] = Private`A; 
      Private`sete /@ Private`Al; Private`Asp]
 
SparseZeroMatrix[Private`n_, Private`m_] := SparseArray[{}, 
     {Private`n, Private`m}]
 
ScalarToMatrixMatrix := BlockDiagonalMatrix[{#1, #1, #1, #1}] & 
 
ToUnitCircle[Private`lf_LFun] := SetDomain[Private`lf, UnitCircle]
 
ToUnitCircle /: ToUnitCircle::usage = 
     "ToUnitCircle[lfun] maps lfun to an LFun defined over the unit circle."
 
RemoveZeros[{Private`v___, _?(Norm[#1] == 0 & )}] := RemoveZeros[{Private`v}]
 
RemoveZeros[Private`v_List] := Private`v
 
RemoveZeros[ShiftList[{Private`v___, _?(Norm[#1] == 0 & )}, Private`ind_]] := 
    RemoveZeros[ShiftList[{Private`v}, Private`ind]]
 
RemoveZeros[ShiftList[{_?(Norm[#1] == 0 & ), Private`v___}, Private`ind_]] := 
    RemoveZeros[ShiftList[{Private`v}, Private`ind - 1]]
 
RemoveZeros[Private`v_ShiftList] := Private`v
 
$MachineTolerance = 1.*^-13
 
$MachineTolerance /: $MachineTolerance::usage = "A specified tolerance for \
when two numerical values should be treated as equal."
 
Private`AdaptiveLFun[Private`m_Integer, Private`f_, Private`d_, 
     Private`pars:OptionsPattern[]] := Module[{Private`prec}, 
     Private`prec = InterpolationPrecision /. {Private`pars} /. 
        Options[Private`AdaptiveLFun]; LFun[Private`f, Private`d, 
       Length[ChopDrop[(If[Max[Abs[Flatten[ToList[FFT[#1]][[{1, 2, -1, 
                  -2}]]]]] < Private`prec, #1, Private`AdaptiveLFun[
             2*Private`m, Private`f, Private`d, Private`pars]] & )[
          LFun[Private`f, Private`d, Private`m]], Private`prec]]]]
 
Options[Private`AdaptiveLFun] := {InterpolationPrecision -> $MachineTolerance}
 
ChopDrop[Private`cf_IFun] := 
    IFun[InverseDCT[(Which[Length[#1] == 0, {0, 0}, Length[#1] == 1, 
         {#1[[1]], 0*#1[[1]]}, True, #1] & )[ChopDrop[DCT[Private`cf]]]], 
     Domain[Private`cf]]
 
ChopDrop[Private`cf_LFun] := 
    LFun[InverseFFT[(SetIndexRange[#1, {-Max[Abs[IndexRange[#1]]], 
          Max[Abs[IndexRange[#1]]]}] & )[
       (Which[Length[#1] == 0, ShiftList[{0, 0, 0}, 2], IndexRange[#1] == 
           {0, 0}, ShiftList[{0*#1[[0]], #1[[0]], 0*#1[[0]]}, 2], True, 
          #1] & )[ChopDrop[FFT[Private`cf]]]]], Domain[Private`cf]]
 
ChopDrop[Private`v_] := RemoveZeros[Chop[Private`v]]
 
ChopDrop[Private`cf_IFun, Private`prec_] := 
    IFun[InverseDCT[(Which[Length[#1] == 0, {0, 0}, Length[#1] == 1, 
         {#1[[1]], 0*#1[[1]]}, True, #1] & )[ChopDrop[DCT[Private`cf], 
        Private`prec]]], Domain[Private`cf]]
 
ChopDrop[Private`cf_LFun, Private`prec_] := 
    LFun[InverseFFT[(SetIndexRange[#1, {-Max[Abs[IndexRange[#1]]], 
          Max[Abs[IndexRange[#1]]]}] & )[
       (Which[Length[#1] == 0, ShiftList[{0, 0, 0}, 2], IndexRange[#1] == 
           {0, 0}, ShiftList[{0*#1[[0]], #1[[0]], 0*#1[[0]]}, 2], True, 
          #1] & )[ChopDrop[FFT[Private`cf], Private`prec]]]], 
     Domain[Private`cf]]
 
ChopDrop[Private`v_, Private`prec_] := RemoveZeros[
     Chop[Private`v, Private`prec]]
 
NZeroQ[Private`sl_List] := NZeroQ[Max[Abs[Private`sl]]]
 
NZeroQ[Private`sl_ShiftList] := NZeroQ[ToList[Private`sl]]
 
NZeroQ[Private`f_] := NEqual[Private`f, 0]
 
ChebyshevLobattoDerivative[Private`c_List] := 
    InverseDCT[ChebyshevD[DCT[Private`c]]]
 
ChebyshevLobattoDerivative /: ChebyshevLobattoDerivative::usage = "Maps a \
list of function values at Chebyshev points to those of its derivative."
 
ChebyshevD[Private`c_List] := Module[{Private`d, Private`n}, 
     Private`n = Length[Private`c]; If[Private`n == 1, {0*Private`c[[1]]}, 
       Private`d[Private`n] = Private`d[Private`n - 1] = 0*Private`c[[1]]; 
        Do[Private`d[Private`k] = Private`d[Private`k + 2] + 
           2*(Private`k + 1)*Private`c[[Private`k + 2]], 
         {Private`k, Private`n - 2, 1, -1}]; Private`d[0] = 
         Private`d[2]/2 + Private`c[[2]]; Array[Private`d[#1 - 1] & , 
         {Private`n}]]]
 
ChebyshevD /: ChebyshevD::usage = 
     "Maps a list of Chebyshev coefficients to those of its derivative."
 
ChebyshevLobattoIntegrate[Private`c_List] := 
    InverseDCT[ChebyshevI[DCT[Private`c]]]
 
ChebyshevLobattoIntegrate /: ChebyshevLobattoIntegrate::usage = "Maps a list \
of function values at Chebyshev points to those of its indefinite integral."
 
ChebyshevI[Private`c_List] := Module[{Private`c2}, 
     Private`c2 = ZeroVector[Length[Private`c] + 1]; 
      Private`c2[[2]] = Private`c[[1]]; Private`c2[[1]] = Private`c[[1]]; 
      If[Length[Private`c] > 1, Private`c2[[3]] = Private`c[[2]]/4; 
        Private`c2[[1]] = Private`c2[[1]] - Private`c[[2]]/4; 
        Table[Private`c2[[Private`k + 1]] = Private`c2[[Private`k + 1]] + 
            Private`c[[Private`k]]/(2*Private`k); 
          Private`c2[[Private`k - 1]] = Private`c2[[Private`k - 1]] - 
            Private`c[[Private`k]]/(2*(Private`k - 2)); Private`c2[[1]] = 
           Private`c2[[1]] + (-1)^Private`k*Private`c[[Private`k]]*
             (1/(2*(Private`k - 2)) - 1/(2*Private`k)); , 
         {Private`k, 3, Length[Private`c]}]]; Private`c2]
 
ChebyshevI /: ChebyshevI::usage = 
     "Maps a list of Chebyshev coefficients to those of its indefinite \
integral."
 
ZeroVector[Private`n_] := Table[0, {Private`n}]
 
ZeroVector /: ZeroVector::usage = 
     "ZeroVector[n] constructs a vector of length n of all zeros."
 
ComplexRoots[(Private`cf_IFun)?UnitIntervalFunQ] := 
    Module[{Private`dct}, Private`dct = RemoveZeros[Chop[DCT[Private`cf], 
         $MachineTolerance]]; Which[Length[Private`dct] <= 1, {}, 
       Length[Private`dct] == 2, {-(Private`dct[[1]]/Private`dct[[2]])}, 
       True, Eigenvalues[-PadLeft[{Most[Private`dct]/(2*Last[Private`dct])}, 
           {Length[Private`dct] - 1, Length[Private`dct] - 1}] + 
         SparseArray[{{1, 2} -> 1, {Private`i_, Private`j_} /; 
             Private`j == Private`i + 1 -> 0.5, {Private`i_, Private`j_} /; 
             Private`j == Private`i - 1 -> 0.5}, {Length[Private`dct] - 1, 
           Length[Private`dct] - 1}]]]]
 
ComplexRoots[Private`cf_IFun] := MapFromInterval[Private`cf, 
     ComplexRoots[ToUnitInterval[Private`cf]]]
 
ComplexRoots[Private`lf_LFun] := ComplexRoots[Domain[Private`lf], 
     ChopDrop[FFT[Private`lf], $MachineTolerance]]
 
ComplexRoots[Private`d_, (Private`fft_ShiftList)?(Length[#1] == 1 & )] := 
    Which[Index[Private`fft] == 1, {}, Index[Private`fft] > 1, Infinity, 
     True, 0]
 
ComplexRoots[Private`d_, (Private`fft_ShiftList)?(Length[#1] == 2 & )] := 
    Module[{Private`dct}, Private`dct = ToList[Private`fft]; 
      {-(Private`dct[[1]]/Private`dct[[2]])}]
 
ComplexRoots[Private`d_, Private`fft_ShiftList] := 
    Module[{Private`dct}, Private`dct = ToList[Private`fft]; 
      MapFromCircle[Private`d, Eigenvalues[
        N[Normal[Transpose[Join[Transpose[SparseArray[{Private`i_, 
                 Private`j_} /; Private`j == Private`i - 1 -> 1, 
              {Length[Private`dct] - 1, Length[Private`dct] - 2}]], 
            -({Most[Private`dct]}/Last[Private`dct])]]]]]]]
 
ComplexRoots /: ComplexRoots::usage = "Returns all roots"
 
UnitIntervalFunQ[Private`f_IFun] := N[Domain[Private`f]] === N[UnitInterval]
 
UnitIntervalFunQ[_] := False
 
UnitIntervalFunQ /: UnitIntervalFunQ::usage = 
     "Tests whether an object is an IFun whose domain is the unit interval."
 
ToUnitInterval[Private`lf_IFun] := SetDomain[Private`lf, UnitInterval]
 
ToUnitInterval /: ToUnitInterval::usage = 
     "ToUnitInterval[ifun] maps ifun to an IFun defined over the unit \
interval."
 
Endpoints[Private`GG_IFun] := {Chop[N[LeftEndpoint[Private`GG]]], 
      Chop[N[RightEndpoint[Private`GG]]]} /. _?InfinityQ -> Infinity
 
Endpoints[Private`GG_List] := Union[Flatten[Endpoints /@ Private`GG], 
     SameTest -> NEqual]
 
Endpoints /: Endpoints::usage = "Returns all endpoints of a list of funs"
 
Private`AdaptiveIFun[Private`m_Integer, Private`f_, Private`d_, 
     Private`pars:OptionsPattern[]] := Module[{Private`prec}, 
     Private`prec = InterpolationPrecision /. {Private`pars} /. 
        Options[Private`AdaptiveIFun]; 
      (IFun[Private`f, Private`d, Length[#1]] & )[
       (ChopDrop[#1, Private`prec*Max[$MachineTolerance, 
            Norm /@ Values[#1]]] & )[
        (If[Max[Abs[Flatten[DCT[#1][[-2 ;; -1]]]]] < Private`prec*
             Max[$MachineTolerance, Norm /@ Values[#1]], #1, 
           Private`AdaptiveIFun[2*Private`m, Private`f, Private`d, 
            Private`pars]] & )[IFun[Private`f, Private`d, Private`m]]]]]
 
Options[Private`AdaptiveIFun] := {InterpolationPrecision -> $MachineTolerance}
 
SignChange[Private`x_, Private`y_] := If[Sign[Private`x]*Sign[Private`y] == 
      -1, True, False]
 
CreateDomains[Private`V_] := Module[{Private`i, Private`out}, 
     Private`out = {}; For[Private`i = 1, Private`i <= Length[Private`V], 
       Private`i = Private`i, If[Private`V[[Private`i,2]] == 1, 
         Private`out = Join[Private`out, {Line[{Private`V[[Private`i,1]], 
               Private`V[[Private`i + 1,1]]}]}]; Private`i = Private`i + 2; , 
         Private`i = Private`i + 1; ]; ]; Private`out]
 
\[Theta][k_, x_, t_] := I*k*x - I*k^2*t
 
q0h1[k_] := q0hnl[k]
 
q0hnl[k_] := LevinInt[my1f[k], my1g[k], my1dg[k], 0, 50, nfwd, 1, False]
 
LevinInt[f_, g_, dg_, r0_, r1_, n_, trunc_, check_] := 
    Module[{f3b3, ans, IIm, IImb, id, A, rhs, mu, f3b3trundom, f3b3exact, 
      newr0, newr1}, f3b3trundom = Truncate[tol][{f[#1] & , Line[{r0, r1}], 
         n}]; If[f3b3trundom == {}, ans = 0, 
       f3b3 = Fun[f[#1] & , f3b3trundom, n][[1]]; Last[Values[f3b3]]; 
        newr1 = f3b3trundom[[1]][[1]][[2]]; newr0 = f3b3trundom[[1]][[1]][[
          1]]; IIm = ReduceDimensionIntegrateMatrix[f3b3]; 
        IImb = Reverse[Transpose[Reverse[Transpose[
             ReduceDimensionIntegrateMatrix[ReverseOrientation[f3b3]]]]]]; 
        id = IdentityMatrix[n]; A = id + IImb . DiagonalMatrix[
            Values[Fun[dg[#1] & , Line[{r0, r1}], n]]]; 
        rhs = IImb . Values[f3b3]; mu = LinearSolve[A, rhs]; 
        ans = mu[[n]]*Exp[g[newr1]] - mu[[1]]*Exp[g[newr0]]; 
        If[r1 == Infinity, ans = (-mu[[1]])*Exp[g[r0]]]; 
        If[check, Print[{"DOM", f3b3trundom, "CDN", 
            Norm[A]*Norm[Inverse[A]]}]; f3b3exact = NIntegrate[
            f[k]*Exp[g[k]], {k, r0, r1}, Method -> "LevinRule"]; 
          {ans, "Levin"}; {f3b3exact, "NInt"}; ans - f3b3exact; 
          Abs[ans - f3b3exact]/Abs[f3b3exact]; {f3b3, DCTPlot[f3b3]}; ]; 
        If[check, {ans, f3b3exact}, ans]]]
 
ReduceDimensionIntegrateMatrix[(Private`d_)?DomainQ, Private`n_Integer] := 
    ReduceDimensionMatrix[Private`d, Private`n + 1] . 
     IntegrateMatrix[Private`d, Private`n]
 
ReduceDimensionIntegrateMatrix[Private`f_] := ReduceDimensionIntegrateMatrix[
     Domain[Private`f], Length[Private`f]]
 
ReduceDimensionMatrix[Private`d_, Private`n_] := 
    Inverse[TransformMatrix[Private`d, Private`n - 1]] . 
     IdentityMatrix[Private`n][[1 ;; -2,All]] . TransformMatrix[Private`d, 
      Private`n]
 
ReduceDimensionMatrix[Private`f_] := ReduceDimensionMatrix[Domain[Private`f], 
     Length[Private`f]]
 
TransformMatrix[_?IntervalDomainQ, Private`n_Integer] := 
    Private`DCTTransformMatrix[Private`n]
 
TransformMatrix[_?CircleDomainQ, Private`n_Integer] := 
    Private`FFTTransformMatrix[Private`n]
 
TransformMatrix[(Private`f_)?FunQ] := TransformMatrix[Domain[Private`f], 
     Length[Private`f]]
 
Private`DCTTransformMatrix[Private`n_Integer] := 
    ColumnMap[DCT, IdentityMatrix[Private`n]]
 
ColumnMap[Private`f_, (Private`m_)?VectorQ] := 
    VectorTranspose[Private`f /@ Private`m]
 
ColumnMap[Private`f_, (Private`m_)?MatrixQ] := 
    VectorTranspose[Private`f /@ Transpose[Private`m]]
 
VectorTranspose[(Private`f_)?MatrixQ] := Transpose[Private`f]
 
VectorTranspose[Private`f_] := Private`f
 
Private`FFTTransformMatrix[Private`n_Integer] := 
    ColumnMap[ToList[FFT[#1]] & , IdentityMatrix[Private`n]]
 
IntegrateMatrix[(Private`d_)?IntervalDomainQ, Private`n_Integer] := 
    ColumnMap[ChebyshevLobattoIntegrate, IdentityMatrix[Private`n]] . 
     DiagonalMatrix[MapFromIntervalD[Private`d, Points[UnitInterval, 
        Private`n]]]
 
IntegrateMatrix[Private`f_] := IntegrateMatrix[Domain[Private`f], 
     Length[Private`f]]
 
ReverseOrientation[Line[{Private`a_, Private`b_}, Private`l___]] := 
    Line[{Private`b, Private`a}, Private`l]
 
ReverseOrientation[Arc[Private`z0_, Private`r_, {Private`t0_, 
       Private`t1_}]] := Arc[Private`z0, Private`r, {Private`t1, Private`t0}]
 
ReverseOrientation[Private`f_IFun] := IFun[Reverse[Values[Private`f]], 
     ReverseOrientation[Domain[Private`f]]]
 
ReverseOrientation[Curve[Private`cr_IFun, Private`opts___]] := 
    Curve[Head[Private`cr][Reverse[Values[Private`cr]], Domain[Private`cr]], 
     Private`opts]
 
ReverseOrientation /: ReverseOrientation::usage = 
     "ReverseOrientation[ifun] gives ifun with the orientation reversed."
 
DCTPlot[Private`f_IFun, Private`opts:OptionsPattern[]] := 
    ListLineLogPlot[Norm /@ DCT[Private`f], Private`opts]
 
DCTPlot /: DCTPlot::usage = 
     "LogPlots the norm of the Chebyshev coefficients of an IFun"
 
Attributes[ListLineLogPlot] = {HoldFirst}
 
ListLineLogPlot[Private`h_, Private`opts___] := ListLogPlot[Private`h, 
     Joined -> True, Private`opts]
 
ListLineLogPlot /: ListLineLogPlot::usage = 
     "Like LineLogPlot, but with a logarithmic scale"
 
my1f[k_][x_] := q0[x]*Exp[(-I)*I*Im[k]*x]
 
q0[_?InfinityQ] := 0
 
q0[x_] := Exp[-x]
 
my1g[k_][x_] := (-I)*Re[k]*x
 
my1dg[k_][x_] := (-I)*Re[k]
 
nfwd = 20
 
f1dtrundom2 = {Line[{0.2 + 0.3*I, 0.5 + 0.*I}]}
 
f1dtrundom3 = {Line[{0.5 + 0.*I, 0.7949999999999999 - 0.29499999999999993*I}]}
 
f1d1 = {}
 
f1d2 = {IFun[{-1.863128298768975*^-13 + 3.839389813799319*^-13*I, 
       -1.9744244437603725*^-13 + 4.0717523222884543*^-13*I, 
       -2.348406074462919*^-13 + 4.853731414166063*^-13*I, 
       -3.129411372955714*^-13 + 6.491722213861392*^-13*I, 
       -4.658264214929423*^-13 + 9.712635457008425*^-13*I, 
       -7.714079278140277*^-13 + 1.6188894107297233*^-12*I, 
       -1.4138562549363225*^-12 + 2.990487824174426*^-12*I, 
       -2.8504743910635993*^-12 + 6.084383743227911*^-12*I, 
       -6.2770257423202*^-12 + 1.3537758780045238*^-11*I, 
       -1.4979452843942898*^-11 + 3.2679977621069884*^-11*I, 
       -3.840763881403738*^-11 + 8.485198716651084*^-11*I, 
       -1.048425430130305*^-10 + 2.3478493152791047*^-10*I, 
       -3.017681046641672*^-10 + 6.856244969905981*^-10*I, 
       -9.067707048598703*^-10 + 2.091914482842106*^-9*I, 
       -2.8157589162640147*^-9 + 6.600680637224541*^-9*I, 
       -8.943839373383046*^-9 + 2.131756010775386*^-8*I, 
       -2.8765306009754267*^-8 + 6.974868001683285*^-8*I, 
       -9.274753847712317*^-8 + 2.2888444243382154*^-7*I, 
       -2.9691813766325253*^-7 + 7.460217320571186*^-7*I, 
       -9.351396905183312*^-7 + 2.392808450678586*^-6*I, 
       -2.872543255674686*^-6 + 7.486743395120094*^-6*I, 
       -8.537592629958504*^-6 + 0.000022667242952657136*I, 
       -0.000024374376848605175 + 0.00006592356892398674*I, 
       -0.00006641500733996663 + 0.00018297456364481423*I, 
       -0.00017175924264160926 + 0.0004819516002305434*I, 
       -0.000419646646648884 + 0.0011990484556159134*I, 
       -0.0009650744176406332 + 0.0028071478929255*I, 
       -0.0020834195318721587 + 0.0061671877183386275*I, 
       -0.004214816283345951 + 0.012691807952036796*I, 
       -0.007984140904595443 + 0.024446209583356852*I, 
       -0.014164060032619647 + 0.04407485771242128*I, -0.023555970078598228 + 
        0.07445324109565259*I, -0.036793072836376915 + 0.11805056080010848*I, 
       -0.05411348838946388 + 0.17613586996141872*I, -0.07518459005573072 + 
        0.24809350896041438*I, -0.0990589462980688 + 0.33114033736365744*I, 
       -0.12429698806292327 + 0.4206142865629745*I, -0.14922736900029276 + 
        0.5107825951132412*I, -0.17226002362726864 + 0.5959139144449581*I, 
       -0.19215743128359938 + 0.6712790467804439*I, -0.20819247260515444 + 
        0.7338098603345196*I, -0.2201760319956914 + 0.7823075836539988*I, 
       -0.2283757165617048 + 0.8172495069274126*I, -0.23337494698997768 + 
        0.8403441876816108*I, -0.23591858904468516 + 0.8540015044755304*I, 
       -0.23678108586556718 + 0.8608489013653687*I, -0.2366695613809262 + 
        0.8633592378047135*I, -0.236164762440431 + 0.8636066410095429*I, 
       -0.23569101317377794 + 0.8631293068567839*I, -0.23550459903988624 + 
        0.8628653715857673*I}, Line[{0.2 + 0.3*I, 0.5 + 0.*I}]]}
 
f1d3 = {IFun[{-0.23550459903988624 + 0.8628653715857673*I, 
       -0.2353075411154213 + 0.8625548502683014*I, -0.23463591839722925 + 
        0.8613225402258953*I, -0.23325251163444927 + 0.8582772161596386*I, 
       -0.23077755839491132 + 0.851977181720919*I, -0.22671695121354823 + 
        0.8405170630626302*I, -0.22051263096460028 + 0.8216904852416953*I, 
       -0.21161743624770324 + 0.793249262051706*I, -0.1995963338050492 + 
        0.7532697571943205*I, -0.18424368434108734 + 0.7005994836864942*I, 
       -0.16569419070430683 + 0.6353090333338443*I, -0.14449607952813737 + 
        0.559030731256949*I, -0.12160917484221576 + 0.475037612296619*I, 
       -0.09830605039587173 + 0.38795548960854853*I, -0.07598038913534834 + 
        0.3030944232168962*I, -0.05590407100905617 + 0.22553067601684468*I, 
       -0.039000875230076885 + 0.15918742643566308*I, -0.025707676463978424 + 
        0.10620162386783058*I, -0.015963169649261037 + 0.06676645958813382*I, 
       -0.00931610456169322 + 0.039459903749613626*I, -0.005101696785189456 + 
        0.021887986970027834*I, -0.0026194606155923415 + 
        0.011385036221971165*I, -0.0012610950223086808 + 
        0.005553149618721845*I, -0.0005698141548635126 + 
        0.0025421897331330524*I, -0.0002420929149444631 + 
        0.0010942835455247488*I, -0.00009698755952177886 + 
        0.0004441245319479411*I, -0.000036776206609120046 + 
        0.0001705852272062992*I, -0.000013260745561652663 + 
        0.00006229481760673908*I, -4.572365783117403*^-6 + 
        0.000021748936142301663*I, -1.517324308176661*^-6 + 
        7.305856783686919*^-6*I, -4.881063269078481*^-7 + 
        2.3783014564372163*^-6*I, -1.5342427448853065*^-7 + 
        7.562278602013194*^-7*I, -4.752668056366607*^-8 + 
        2.3688095374336067*^-7*I, -1.4641797095553553*^-8 + 
        7.376208091728043*^-8*I, -4.528963542940676*^-9 + 
        2.3050523292231743*^-8*I, -1.4204318101529199*^-9 + 
        7.3000679413254746*^-9*I, -4.562551945157781*^-10 + 
        2.3665032811861387*^-9*I, -1.5161276426176128*^-10 + 
        7.932011138290072*^-10*I, -5.26438004533247*^-11 + 
        2.776432971822918*^-10*I, -1.9288509340036635*^-11 + 
        1.0248571126589573*^-10*I, -7.528363340196956*^-12 + 
        4.0272888588414993*^-11*I, -3.1583810820144693*^-12 + 
        1.699957909636324*^-11*I, -1.4363157968503205*^-12 + 
        7.773038794298246*^-12*I, -7.135334109301443*^-13 + 
        3.879905979462256*^-12*I, -3.899123942120809*^-13 + 
        2.1287902448478874*^-12*I, -2.357923442717155*^-13 + 
        1.2916398517384261*^-12*I, -1.5859790978170009*^-13 + 
        8.710402168456804*^-13*I, -1.191270565882854*^-13 + 
        6.554807838141502*^-13*I, -1.0021414728154418*^-13 + 
        5.52032718440834*^-13*I, -9.45837866052464*^-14 + 
        5.212123703502089*^-13*I}, Line[{0.5 + 0.*I, 0.7949999999999999 - 
         0.29499999999999993*I}]]}
 
I1 = 0.009886754284119711 + 0.017370584829782505*I
 
f2btrundom1 = {Line[{0.20500000000000007 + 0.29499999999999993*I, 
       0.5 + 0.*I}]}
 
f2btrundom2 = {Line[{0.5 + 0.*I, 0.795 - 0.295*I}]}
 
f2btrundom3 = {}
 
f2b1 = {IFun[{-4.759452911432651*^-13 + 3.878051514647894*^-13*I, 
       -5.041620897902728*^-13 + 4.105746635483439*^-13*I, 
       -5.988994105602389*^-13 + 4.869365518934505*^-13*I, 
       -7.964241614596266*^-13 + 6.457900834991036*^-13*I, 
       -1.1821722877403074*^-12 + 9.54969416918266*^-13*I, 
       -1.9508419352792407*^-12 + 1.5682949329515646*^-12*I, 
       -3.560998245387593*^-12 + 2.845851613437981*^-12*I, 
       -7.146743094792109*^-12 + 5.671843825335619*^-12*I, 
       -1.5661029428674068*^-11 + 1.232981874005669*^-11*I, 
       -3.7183432169877105*^-11 + 2.9010508747217025*^-11*I, 
       -9.484952143412312*^-11 + 7.325966672517012*^-11*I, 
       -2.5761118062078683*^-10 + 1.967790788896995*^-10*I, 
       -7.379489463780544*^-10 + 5.569194922104611*^-10*I, 
       -2.2078218119517557*^-9 + 1.6445885387583729*^-9*I, 
       -6.8302117901833235*^-9 + 5.016938474408022*^-9*I, 
       -2.163029904978541*^-8 + 1.5652105422215425*^-8*I, 
       -6.942260576421693*^-8 + 4.944498657758952*^-8*I, 
       -2.2360557085990356*^-7 + 1.5661498021755502*^-7*I, 
       -7.159388423076373*^-7 + 4.927063748430192*^-7*I, 
       -2.2580551630583395*^-6 + 1.52565443060632*^-6*I, 
       -6.955759844673173*^-6 + 4.6104258703258984*^-6*I, 
       -0.00002076190059307905 + 0.000013490344480992903*I, 
       -0.000059617776302741865 + 0.00003794871116337298*I, 
       -0.00016363989108976083 + 0.00010197773788479803*I, 
       -0.0004269694455698589 + 0.0002603534193848114*I, 
       -0.0010540931158724632 + 0.0006286074573165217*I, 
       -0.0024531312278983667 + 0.0014301126280250507*I, 
       -0.0053668306806196175 + 0.0030574902077119283*I, 
       -0.011017361727991039 + 0.006132081996411316*I, 
       -0.021203683446155523 + 0.01152790056942091*I, -0.0382579674330022 + 
        0.02031598692938495*I, -0.0647716163907304 + 0.03359636087646599*I, 
       -0.10306760711224416 + 0.05222579522099029*I, -0.1545161458428989 + 
        0.07650819502448752*I, -0.21890785188544373 + 0.10595897794765369*I, 
       -0.2941368105603964 + 0.1392505442528127*I, -0.3763600070780749 + 
        0.1743856267065137*I, -0.46062237647818466 + 0.20905571375345575*I, 
       -0.541757032508201 + 0.24107065612523038*I, -0.6152819138437285 + 
        0.26872788208638754*I, -0.6780467795529264 + 0.29102862584274836*I, 
       -0.7285069295037779 + 0.3077138426830936*I, -0.7666377667712967 + 
        0.31915379560279994*I, -0.7935995260249677 + 0.32615358389088644*I, 
       -0.8112929307428549 + 0.3297424655462161*I, -0.8219238835197723 + 
        0.3309909185476027*I, -0.8276484455961468 + 0.33087740801980037*I, 
       -0.8303232184408726 + 0.33020682825776243*I, -0.8313503323267945 + 
        0.32956738318077583*I, -0.831595399083038 + 0.32931467910602513*I}, 
      Line[{0.20500000000000007 + 0.29499999999999993*I, 0.5 + 0.*I}]]}
 
f2b2 = {IFun[{-0.8315953990830356 + 0.32931467910603124*I, 
       -0.8317914488350069 + 0.32904239453326145*I, -0.8320850907928301 + 
        0.32810995488684114*I, -0.8315983096310783 + 0.3261764656409821*I, 
       -0.8288931397659309 + 0.3226958490965374*I, -0.822033347220827 + 
        0.31695818022946026*I, -0.8087135670215873 + 0.30816143829669557*I, 
       -0.7864861716236169 + 0.29552104814494523*I, -0.7531050917071249 + 
        0.2784175803701287*I, -0.7069701705581669 + 0.2565669941361195*I, 
       -0.6476147869044578 + 0.23018257325166216*I, -0.5761172120324962 + 
        0.2000782736290322*I, -0.4952867365020821 + 0.16766145435191324*I, 
       -0.40948588316005496 + 0.13478182555816876*I, -0.32404263426073154 + 
        0.1034448292431764*I, -0.24434193521852174 + 0.07545435568331414*I, 
       -0.17483663142339542 + 0.05208668159311776*I, -0.11827982226707472 + 
        0.0338999300289745*I, -0.07541880827540093 + 0.020734832022718606*I, 
       -0.0452134472024234 + 0.01188795054072745*I, -0.025440103320272592 + 
        0.006376807198930823*I, -0.013422230907022496 + 
        0.00319678214122842*I, -0.006639700164307519 + 0.001497352650559329*
         I, -0.0030820902590490053 + 0.000655701187807643*I, 
       -0.0013448543599952323 + 0.0002688564692510481*I, 
       -0.0005531085235720731 + 0.00010347338355167887*I, 
       -0.00021519642094293369 + 0.00003750475231355474*I, 
       -0.00007956813645479993 + 0.00001285691583481742*I, 
       -0.000028112893870438433 + 4.189782974287639*^-6*I, 
       -9.551896739027622*^-6 + 1.3055888998134052*^-6*I, 
       -3.143356126855358*^-6 + 3.9160642682907077*^-7*I, 
       -1.0097981252450235*^-6 + 1.138834963426749*^-7*I, 
       -3.193792076634338*^-7 + 3.235942473213704*^-8*I, 
       -1.0035489946500676*^-7 + 9.057231507040332*^-9*I, 
       -3.162619729354439*^-8 + 2.5180559482836633*^-9*I, 
       -1.0094503549863345*^-8 + 7.012016440700726*^-10*I, 
       -3.2960184412511244*^-9 + 1.971855929534999*^-10*I, 
       -1.1120539085457101*^-9 + 5.6428019145022035*^-11*I, 
       -3.9158804618279245*^-10 + 1.654418561817025*^-11*I, 
       -1.4532827637011402*^-10 + 4.9963706559640425*^-12*I, 
       -5.738451391571899*^-11 + 1.5588345926335802*^-12*I, 
       -2.4326090246582773*^-11 + 5.019021584192698*^-13*I, 
       -1.1164526461692674*^-11 + 1.6531669258977565*^-13*I, 
       -5.59056701569628*^-12 + 5.4299628115585134*^-14*I, 
       -3.0755872586883395*^-12 + 1.6510460900939678*^-14*I, 
       -1.870157124665896*^-12 + 3.348719153495561*^-15*I, 
       -1.2632875421419374*^-12 - 1.2717609708089743*^-15*I, 
       -9.517886627832968*^-13 - 2.867044072074239*^-15*I, 
       -8.021473907671973*^-13 - 3.384016942791993*^-15*I, 
       -7.575421643089053*^-13 - 3.5008714330729857*^-15*I}, 
      Line[{0.5 + 0.*I, 0.795 - 0.295*I}]]}
 
f2b3 = {}
 
I2 = 0.007932083100489979 - 0.018258809945356447*I
 
p = 0.34538776394910686
 
f3bbtrundom1a = {}
 
g0h1[k_, t_] := g0hnl[k, t]
 
g0hnl[k_, T_] := LevinInt[my3f[k][T], my3g[k][T], my3dg[k][T], 0, T, nfwd, 1, 
     False]
 
my3f[k_][T_][s_] := g0[T - s]*Exp[(-I)*I*Im[k^2]*s]
 
g0[_?InfinityQ] := 0
 
g0[t_] := Exp[-t]
 
my3g[k_][T_][s_] := (-I)*Re[k^2]*s
 
my3dg[k_][T_][s_] := (-I)*Re[k^2]
 
f3bbtrundom2 = {Line[{0.21 + 0.29*I, 0.5 + 0.*I}]}
 
g0t1[k_, t_] := g0tnl[k, t]
 
g0tnl[k_, t_] := LevinInt[my2f[k], my2g[k], my2dg[k], 0, t, nfwd, 1, False]
 
my2f[k_][t_] := g0[t]
 
my2g[k_][t_] := I*k^2*t
 
my2dg[k_][t_] := I*k^2
 
f3bb = {IFun[{-6.531641524670328*^-13 - 4.42915356666468*^-14*I, 
       -6.901685732060931*^-13 - 4.618004462948377*^-14*I, 
       -8.137851053071379*^-13 - 5.225674894881885*^-14*I, 
       -1.0689503490369683*^-12 - 6.384326282289874*^-14*I, 
       -1.5598962283141222*^-12 - 8.337986876857402*^-14*I, 
       -2.519206292636509*^-12 - 1.143933514810592*^-13*I, 
       -4.480912341289925*^-12 - 1.5957614722749638*^-13*I, 
       -8.727765246610317*^-12 - 2.1024024534540528*^-13*I, 
       -1.84927548115918*^-11 - 2.010059803849182*^-13*I, 
       -4.231150489312984*^-11 + 1.6942401665143794*^-13*I, 
       -1.0370079742572489*^-10 + 2.1239101552985168*^-12*I, 
       -2.699233732457515*^-10 + 1.0391741422280891*^-11*I, 
       -7.394547350493184*^-10 + 4.287540545338686*^-11*I, 
       -2.112203510341618*^-9 + 1.665340321234783*^-10*I, 
       -6.231170021840664*^-9 + 6.292274302618389*^-10*I, 
       -1.8803569283585538*^-8 + 2.336849573960561*^-9*I, 
       -5.7490957974040374*^-8 + 8.543301356074363*^-9*I, 
       -1.764316026667765*^-7 + 3.066629750265481*^-8*I, 
       -5.385523850662485*^-7 + 1.0757912715149298*^-7*I, 
       -1.6210172053707288*^-6 + 3.667755157452047*^-7*I, 
       -4.772100122400608*^-6 + 1.2081001381453297*^-6*I, 
       -0.000013636695742108337 + 3.821888729857371*^-6*I, 
       -0.00003756634131204866 + 0.000011547782837642563*I, 
       -0.00009915596068368214 + 0.00003315493750017007*I, 
       -0.0002494373099287936 + 0.00009004894803871527*I, 
       -0.0005953748741805864 + 0.00023048952707520055*I, 
       -0.0013435504632930105 + 0.0005543258098934085*I, 
       -0.002858841990858651 + 0.0012498996490939243*I, 
       -0.005725688367839497 + 0.0026387601071543613*I, 
       -0.010783989314200557 + 0.00521340575085915*I, -0.019099847087249898 + 
        0.009642237127973456*I, -0.03183589284923312 + 0.016712729273977604*
         I, -0.05001597115373071 + 0.027197469465167635*I, 
       -0.07422904888102322 + 0.04165932469805519*I, -0.10436374595065773 + 
        0.060249107482652935*I, -0.13947750750453977 + 0.08256969468032078*I, 
       -0.17786752689650004 + 0.10766754831169438*I, -0.21733758412646723 + 
        0.13416790475548618*I, -0.25558224165316573 + 0.16051541261256871*I, 
       -0.29057306068874694 + 0.18524546514506446*I, -0.3208440417354747 + 
        0.2072087230968611*I, -0.3456218088972852 + 0.2256984170637222*I, 
       -0.3648025031632075 + 0.24046926600699817*I, -0.3788179672295343 + 
        0.2516695441314226*I, -0.3884487439252964 + 0.2597237987438208*I, 
       -0.3946344759914251 + 0.26520311736214447*I, -0.3983140355107198 + 
        0.26870911877083226*I, -0.4003083413603541 + 0.2707844786262693*I, 
       -0.4012445072050903 + 0.27185195193299244*I, -0.4015125539056794 + 
        0.27217758730142116*I}, Line[{0.21 + 0.29*I, 0.5 + 0.*I}]]}
 
I3a = -0.0022000898602101025 + 0.009729466209212978*I
 
f3ctrundom2 = {}
 
g0t2[k_, t_] := g0tnl2[k, t]
 
g0tnl2[k_, t_] := LevinInt[my2f[k], my2g[k], my2dg[k], t, Infinity, nfwd, 1, 
     False]
 
f3c = {}
 
I3c = 0
 
g3[xx_, tt_][_?InfinityQ] := 0
 
g3[xx_, tt_][k_] := I*k*xx - I*tt*k^2
 
dg3[xx_, tt_][_?InfinityQ] := 0
 
dg3[xx_, tt_][k_] := I*xx - 2*I*k*tt
 
g0texactk[tt_][_?InfinityQ] := 0
 
g0texactk[tt_][k_] := g0t1[k, Infinity]*k
 
iii = -0.0020145221032146377 + 0.011656352258302707*I
mylNLS[1., 1., 50] = 0.371586198641526 - 0.039609366597684166*I
 
mylNLS[1., 2., 50] = 0.19575544149357946 - 0.08446450307505701*I
 
mylNLS[1., 3., 50] = 0.09645466972238098 - 0.0749794431851458*I
 
mylNLS[1., 4., 50] = 0.048289238137408756 - 0.05782484241891702*I
 
mylNLS[1., 5., 50] = 0.02541016130179833 - 0.0435571921031745*I
 
mylNLS[1., 6., 50] = 0.014315362525845953 - 0.03324869143375817*I
 
mylNLS[1., 8., 50] = 0.005684068536640414 - 0.020918862934075463*I
 
mylNLS[1., 10., 50] = 0.0028910049859440855 - 0.014500858323837091*I
 
mylNLS[1., 20., 50] = 0.0004400983996490867 - 0.004788432769286744*I
 
mylNLS[1., 40., 50] = 0.0000733004103599197 - 0.001635399174458025*I
 
mylNLS[1., 80., 50] = 0.0000125702351904708 - 0.0005679313150632106*I
 
mylNLS[1., 160., 50] = 2.1909195606157*^-6 - 0.00019896106800729*I
 
mylNLS[1., 320., 50] = 3.8328077430431874*^-7 - 0.00007001831601145559*I
 
mylNLS[1., 500., 50] = 1.2518873827697183*^-7 - 0.0000357884980630959*I
 
mylNLS[1., 1000., 50] = 2.191769675070834*^-8 - 0.000012634208595170598*I
 
mylNLS[1., 2000., 50] = 3.9023496089392116*^-9 - 4.463576253596789*^-6*I
 
mylNLS[1., 4000., 50] = 6.594140452767689*^-10 - 1.577470525123945*^-6*I
 
mylNLS[1., 8000., 50] = 9.285146192151827*^-11 - 5.605301256718198*^-7*I
 
mylNLS[2., 1., 50] = 0.2705312703485232 + 0.10501308590542738*I
 
mylNLS[2., 2., 50] = 0.2449858748992166 - 0.03636420096416831*I
 
mylNLS[2., 3., 50] = 0.15565814678768208 - 0.08226163354183898*I
 
mylNLS[2., 4., 50] = 0.09251268559480849 - 0.08300445104182756*I
 
mylNLS[2., 5., 50] = 0.055341128735959665 - 0.07129560335915548*I
 
mylNLS[2., 6., 50] = 0.034308904225212704 - 0.058573327596219804*I
 
mylNLS[2., 8., 50] = 0.015224190594702492 - 0.03949603483251569*I
 
mylNLS[2., 10., 50] = 0.008079173259908031 - 0.02810262140254422*I
 
mylNLS[2., 20., 50] = 0.0012542291302028307 - 0.00951471078190088*I
 
mylNLS[2., 40., 50] = 0.0002093332911425748 - 0.003265812748134345*I
 
mylNLS[2., 80., 50] = 0.0000359233932581939 - 0.0011354411418275354*I
 
mylNLS[2., 160., 50] = 6.256508321876998*^-6 - 0.00039788710402929926*I
 
mylNLS[2., 320., 50] = 1.0962730335139947*^-6 - 0.00014003404121627994*I
 
mylNLS[2., 500., 50] = 3.5803990675698183*^-7 - 0.00007157746481660602*I
 
mylNLS[2., 1000., 50] = 6.2930125677804*^-8 - 0.00002526880772314976*I
 
mylNLS[2., 2000., 50] = 1.1126153824243197*^-8 - 8.927252310760031*^-6*I
 
mylNLS[2., 4000., 50] = 1.929128032330114*^-9 - 3.155046504850717*^-6*I
 
mylNLS[2., 8000., 50] = 2.9791234744171047*^-10 - 1.1180613162525363*^-6*I
 
mylNLS[3., 1., 50] = 0.03943902937694643 + 0.14908012052202335*I
 
mylNLS[3., 2., 50] = 0.20940171964048027 + 0.09312948378227613*I
 
mylNLS[3., 3., 50] = 0.19720510081756537 - 0.014276439206048527*I
 
mylNLS[3., 4., 50] = 0.14318225833301318 - 0.06062353597179331*I
 
mylNLS[3., 5., 50] = 0.09710437278795088 - 0.07147752576267657*I
 
mylNLS[3., 6., 50] = 0.06546127810704128 - 0.06810327686900453*I
 
mylNLS[3., 8., 50] = 0.031863854404371526 - 0.05246529687731767*I
 
mylNLS[3., 10., 50] = 0.017556716076039557 - 0.039351321792347134*I
 
mylNLS[3., 20., 50] = 0.0028048659927740693 - 0.014069420783181229*I
 
mylNLS[3., 40., 50] = 0.0004703701203145228 - 0.0048821785891786165*I
 
mylNLS[3., 80., 50] = 0.00008080976921024291 - 0.0017017575624022612*I
 
mylNLS[3., 160., 50] = 0.000014074571382811441 - 0.0005967098725882595*I
 
mylNLS[3., 320., 50] = 2.4676842642252123*^-6 - 0.0002100407350877953*I
 
mylNLS[3., 500., 50] = 8.060486132745238*^-7 - 0.00010736454728887094*I
 
mylNLS[3., 1000., 50] = 1.4188359584085063*^-7 - 0.00003790324112850645*I
 
mylNLS[3., 2000., 50] = 2.5048688952750476*^-8 - 0.000013390915188779353*I
 
mylNLS[3., 4000., 50] = 4.38231800327117*^-9 - 4.73260419726219*^-6*I
 
mylNLS[3., 8000., 50] = 7.124070280136104*^-10 - 1.6756879686938236*^-6*I
 
mylNLS[4., 1., 50] = -0.05052674800343645 - 0.0002882644756767999*I
 
mylNLS[4., 2., 50] = 0.056237900423356926 + 0.17161810084045173*I
 
mylNLS[4., 3., 50] = 0.1672156484684832 + 0.0966415391129573*I
 
mylNLS[4., 4., 50] = 0.16911730619592358 + 0.011880650055723252*I
 
mylNLS[4., 5., 50] = 0.1363421009379077 - 0.03416857287083219*I
 
mylNLS[4., 6., 50] = 0.10219925029254542 - 0.05261587632518071*I
 
mylNLS[4., 8., 50] = 0.0557914085038172 - 0.05487244756035686*I
 
mylNLS[4., 10., 50] = 0.03232753626431016 - 0.04579541552920671*I
 
mylNLS[4., 20., 50] = 0.005422017772665745 - 0.018248660039585606*I
 
mylNLS[4., 40., 50] = 0.0009173562216168987 - 0.006467512439998817*I
 
mylNLS[4., 80., 50] = 0.00015793028645998662 - 0.0022654334690051926*I
 
mylNLS[4., 160., 50] = 0.000027518567815357318 - 0.0007953040278421774*I
 
mylNLS[4., 320., 50] = 4.826602314263729*^-6 - 0.00028002743338147884*I
 
mylNLS[4., 500., 50] = 1.576778279222759*^-6 - 0.00014314745492699868*I
 
mylNLS[4., 1000., 50] = 2.777481810805097*^-7 - 0.00005053730702862336*I
 
mylNLS[4., 2000., 50] = 4.901937498984022*^-8 - 0.00001785454566996174*I
 
mylNLS[4., 4000., 50] = 8.61067256017547*^-9 - 6.31015906396267*^-6*I
 
mylNLS[4., 8000., 50] = 1.441096479479514*^-9 - 2.233314736783443*^-6*I
 
mylNLS[5., 1., 50] = 0.03713127997407489 - 0.012387260386892446*I
 
mylNLS[5., 2., 50] = -0.09320844041348261 + 0.08681786024130153*I
 
mylNLS[5., 3., 50] = 0.04647198319565063 + 0.16541431591084377*I
 
mylNLS[5., 4., 50] = 0.13258399761544265 + 0.10534134960200875*I
 
mylNLS[5., 5., 50] = 0.1459685639062437 + 0.03708075466621284*I
 
mylNLS[5., 6., 50] = 0.1287422272307095 - 0.007329515273693375*I
 
mylNLS[5., 8., 50] = 0.08281109149580411 - 0.04115618977015939*I
 
mylNLS[5., 10., 50] = 0.05163310063985742 - 0.044062245650742425*I
 
mylNLS[5., 20., 50] = 0.009365675800144087 - 0.021716465864841862*I
 
mylNLS[5., 40., 50] = 0.0016083747446526166 - 0.007993090675015354*I
 
mylNLS[5., 80., 50] = 0.00027786525679536587 - 0.00282400556008749*I
 
mylNLS[5., 160., 50] = 0.000048456761639683286 - 0.000993455844008689*I
 
mylNLS[5., 320., 50] = 8.501888776800873*^-6 - 0.00034997543498066096*I
 
mylNLS[5., 500., 50] = 2.777762493555692*^-6 - 0.000178922281378485*I
 
mylNLS[5., 1000., 50] = 4.894925876103173*^-7 - 0.00006317066139739492*I
 
mylNLS[5., 2000., 50] = 8.638753520230612*^-8 - 0.000022318113397848605*I
 
mylNLS[5., 4000., 50] = 1.520592387770684*^-8 - 7.887708399441233*^-6*I
 
mylNLS[5., 8000., 50] = 2.588555315224977*^-9 - 2.790941060161436*^-6*I
 
mylNLS[6., 1., 50] = -0.01594620251020093 + 0.019229098623804664*I
 
mylNLS[6., 2., 50] = -0.06592516088304565 - 0.058021498165067256*I
 
mylNLS[6., 3., 50] = -0.0904611740547082 + 0.11156484069260085*I
 
mylNLS[6., 4., 50] = 0.02669497740413905 + 0.15681684765531134*I
 
mylNLS[6., 5., 50] = 0.1008402435836596 + 0.11387919249200482*I
 
mylNLS[6., 6., 50] = 0.12318343636261131 + 0.059244179863206584*I
 
mylNLS[6., 8., 50] = 0.10342554010962071 - 0.008166508419608694*I
 
mylNLS[6., 10., 50] = 0.07206315702467031 - 0.0307032842421855*I
 
mylNLS[6., 20., 50] = 0.01476588346759548 - 0.023984160259662095*I
 
mylNLS[6., 40., 50] = 0.002596073540587345 - 0.009415002600417681*I
 
mylNLS[6., 80., 50] = 0.00045096436757434703 - 0.0033736652822687315*I
 
mylNLS[6., 160., 50] = 0.00007874747214229488 - 0.0011908339693910922*I
 
mylNLS[6., 320., 50] = 0.00001382197106974507 - 0.0004198557266671368*I
 
mylNLS[6., 500., 50] = 4.516476583020873*^-6 - 0.00021468296446271298*I
 
mylNLS[6., 1000., 50] = 7.960830395505543*^-7 - 0.00007580277025660243*I
 
mylNLS[6., 2000., 50] = 1.4050240233036635*^-7 - 0.00002678157127595494*I
 
mylNLS[6., 4000., 50] = 2.4759809029993397*^-8 - 9.465248062290576*^-6*I
 
mylNLS[6., 8000., 50] = 4.259330497213705*^-9 - 3.348566544868137*^-6*I
 
mylNLS[8., 1., 50] = -0.011118328587313934 - 0.0004916281989922611*I
 
mylNLS[8., 2., 50] = 0.014189932180827883 + 0.04732288479241996*I
 
mylNLS[8., 3., 50] = 0.0003565927263855795 - 0.09353050033026578*I
 
mylNLS[8., 4., 50] = -0.12446723411461522 - 0.014333544538113807*I
 
mylNLS[8., 5., 50] = -0.09654604260385403 + 0.0982085807986417*I
 
mylNLS[8., 6., 50] = -0.019545636094628713 + 0.1351895999592963*I
 
mylNLS[8., 8., 50] = 0.07450253442550768 + 0.09047890744857723*I
 
mylNLS[8., 10., 50] = 0.08830003625734556 + 0.033666849497342465*I
 
mylNLS[8., 20., 50] = 0.029299743444599215 - 0.022306680037970535*I
 
mylNLS[8., 40., 50] = 0.005620162734475544 - 0.011680426839575844*I
 
mylNLS[8., 80., 50] = 0.0009958141879249974 - 0.004422416041357983*I
 
mylNLS[8., 160., 50] = 0.000174722745997604 - 0.001581182310179736*I
 
mylNLS[8., 320., 50] = 0.000030705998793014155 - 0.0005592301692494834*I
 
mylNLS[8., 500., 50] = 0.000010036430249701084 - 0.00028612364937974854*I
 
mylNLS[8., 1000., 50] = 1.7696419057827421*^-6 - 0.0001010598816298785*I
 
mylNLS[8., 2000., 50] = 3.12368073320986*^-7 - 0.00003570786018573754*I
 
mylNLS[8., 4000., 50] = 5.511024079273516*^-8 - 0.000012620272059509589*I
 
mylNLS[8., 8000., 50] = 9.58915644700674*^-9 - 4.463812773024137*^-6*I
 
mylNLS[10., 1., 50] = 0.005826178845184077 - 0.0016481709673239059*I
 
mylNLS[10., 2., 50] = 0.026740280559151147 - 0.010934448405277776*I
 
mylNLS[10., 3., 50] = 0.00023952199939859808 + 0.06177509122730189*I
 
mylNLS[10., 4., 50] = 0.0732093555170249 - 0.056499153656008605*I
 
mylNLS[10., 5., 50] = -0.04994579959998624 - 0.10190425661553547*I
 
mylNLS[10., 6., 50] = -0.12130765512405745 - 0.021646563002518368*I
 
mylNLS[10., 8., 50] = -0.06038962912364724 + 0.10345460635599767*I
 
mylNLS[10., 10., 50] = 0.023729690997736207 + 0.1012303353178595*I
 
mylNLS[10., 20., 50] = 0.0441647712827928 - 0.007918966470476747*I
 
mylNLS[10., 40., 50] = 0.010117314347317823 - 0.012533368172324467*I
 
mylNLS[10., 80., 50] = 0.0018623437283658982 - 0.005343005135493718*I
 
mylNLS[10., 160., 50] = 0.00032974795488335275 - 0.0019602599216960452*I
 
mylNLS[10., 320., 50] = 0.000058081491837527765 - 0.0006976151463416314*I
 
mylNLS[10., 500., 50] = 0.000018993154444628703 - 0.00035735749437096895*I
 
mylNLS[10., 1000., 50] = 3.350009594865999*^-6 - 0.0001262987693019737*I
 
mylNLS[10., 2000., 50] = 5.914038357575808*^-7 - 0.000044632541313027824*I
 
mylNLS[10., 4000., 50] = 1.043955334591681*^-7 - 0.000015775154167613697*I
 
mylNLS[10., 8000., 50] = 1.8267118866932973*^-8 - 5.579046624832784*^-6*I
 
mylNLS[20., 1., 50] = 0.0006649618806321908 - 0.0004244509987532579*I
 
mylNLS[20., 2., 50] = 0.004033487412872551 - 0.0015240530430359264*I
 
mylNLS[20., 3., 50] = -0.00201793213574554 + 0.011012888257083082*I
 
mylNLS[20., 4., 50] = 0.019637596744995683 - 0.007783426231870311*I
 
mylNLS[20., 5., 50] = 0.02257879611666698 + 0.02422548325664419*I
 
mylNLS[20., 6., 50] = -0.039324814698426025 - 0.023614232852250297*I
 
mylNLS[20., 8., 50] = 0.05442998249827955 - 0.04212674884249617*I
 
mylNLS[20., 10., 50] = -0.08236798913351967 + 0.014820643055592046*I
 
mylNLS[20., 20., 50] = -0.05865027824911777 - 0.041359616758437995*I
 
mylNLS[20., 40., 50] = 0.015765004104508016 + 0.02629056384016022*I
 
mylNLS[20., 80., 50] = 0.010726677074934458 - 0.0031562286718763207*I
 
mylNLS[20., 160., 50] = 0.002361889547839504 - 0.0031833007646486938*I
 
mylNLS[20., 320., 50] = 0.0004376606470340424 - 0.001328806169046085*I
 
mylNLS[20., 500., 50] = 0.0001445325815070105 - 0.0007007593998936371*I
 
mylNLS[20., 1000., 50] = 0.00002562532971586045 - 0.00025136501506082317*I
 
mylNLS[20., 2000., 50] = 4.530189376229293*^-6 - 0.00008915632967322222*I
 
mylNLS[20., 4000., 50] = 8.004507841608003*^-7 - 0.0000315407676419769*I
 
mylNLS[20., 8000., 50] = 1.411542422480238*^-7 - 0.000011154441785607163*I
 
mylNLS[40., 1., 50] = -0.00005251108555680197 - 0.00008271895958594268*I
 
mylNLS[40., 2., 50] = 0.0002598551473471551 - 0.0004941869682974975*I
 
mylNLS[40., 3., 50] = 0.00034400706423418255 + 0.0014789749551296777*I
 
mylNLS[40., 4., 50] = 0.0025266642440165132 - 0.001724846099891297*I
 
mylNLS[40., 5., 50] = -0.0010703955591034042 - 0.005104574365240769*I
 
mylNLS[40., 6., 50] = -0.006741824848909586 - 0.004275038990559796*I
 
mylNLS[40., 8., 50] = 0.013528783344337922 - 0.006841899292355923*I
 
mylNLS[40., 10., 50] = -0.010219059011688368 + 0.02164283214939106*I
 
mylNLS[40., 20., 50] = 0.05646703019973594 + 0.02287425659224529*I
 
mylNLS[40., 40., 50] = -0.03782788989544485 + 0.03255822361633363*I
 
mylNLS[40., 80., 50] = -0.019872879958239137 - 0.007690015010710866*I
 
mylNLS[40., 160., 50] = 0.00452971375023656 + 0.006391773850591068*I
 
mylNLS[40., 320., 50] = 0.002654957094379344 - 0.0008568748357355851*I
 
mylNLS[40., 500., 50] = 0.0010298834795327786 - 0.0009910722001871938*I
 
mylNLS[40., 1000., 50] = 0.00019760891467875233 - 0.0004649318525081856*I
 
mylNLS[40., 2000., 50] = 0.0000356157734348317 - 0.00017494072581102787*I
 
mylNLS[40., 4000., 50] = 6.324160544678086*^-6 - 0.00006278301884438589*I
 
mylNLS[40., 8000., 50] = 1.1185840674183348*^-6 - 0.000022279703967542857*I
 
mylNLS[80., 1., 50] = -8.162537720058293*^-6 - 9.875644810821392*^-6*I
 
mylNLS[80., 2., 50] = -0.00003112657474409024 + 0.00006307960995164796*I
 
mylNLS[80., 3., 50] = 0.00014156050912413412 - 0.0001315197796284413*I
 
mylNLS[80., 4., 50] = -0.00021325323123746283 - 0.0003323665390002131*I
 
mylNLS[80., 5., 50] = 0.0006123946906221398 - 0.0003089413967125691*I
 
mylNLS[80., 6., 50] = -0.0009887116357487954 + 0.00042041879308710867*I
 
mylNLS[80., 8., 50] = 0.0009515865061973938 - 0.0019458133204378865*I
 
mylNLS[80., 10., 50] = -0.0035306812518062017 + 0.001094221090980469*I
 
mylNLS[80., 20., 50] = -0.006316981259318125 - 0.01590553496685898*I
 
mylNLS[80., 40., 50] = 0.0019371694183992517 + 0.043760193486265336*I
 
mylNLS[80., 80., 50] = 0.034539784255910436 - 0.005420773778399494*I
 
mylNLS[80., 160., 50] = -0.009007443670681913 + 0.011918922680268387*I
 
mylNLS[80., 320., 50] = -0.005254784839295876 - 0.0016713246310699327*I
 
mylNLS[80., 500., 50] = -0.00019276322878801228 + 0.0028382990884926523*I
 
mylNLS[80., 1000., 50] = 0.0010086266888651937 + 0.00003258889227261057*I
 
mylNLS[80., 2000., 50] = 0.0002563453990911038 - 0.0002483977125665171*I
 
mylNLS[80., 4000., 50] = 0.000049195758672814587 - 0.00011620762173206867*I
 
mylNLS[80., 8000., 50] = 8.871437103425556*^-6 - 0.000043720974489966824*I
 
mylNLS[160., 1., 50] = -9.907591468419352*^-7 - 7.512080420360792*^-7*I
 
mylNLS[160., 2., 50] = -2.4874564120841436*^-6 + 8.450771141504509*^-6*I
 
mylNLS[160., 3., 50] = -0.000023824373910085166 - 4.558778139591817*^-6*I
 
mylNLS[160., 4., 50] = -0.00002993778109227187 - 0.00003972102056013123*I
 
mylNLS[160., 5., 50] = -0.000017686897907476934 - 0.00008494757722621576*I
 
mylNLS[160., 6., 50] = 0.000011943210504888196 - 0.0001361150345202851*I
 
mylNLS[160., 8., 50] = -0.00012170948899505388 + 0.0002513409329465426*I
 
mylNLS[160., 10., 50] = 0.0002995902201243395 - 0.00038151526438498593*I
 
mylNLS[160., 20., 50] = 0.0022791327230965597 - 0.001284779306360096*I
 
mylNLS[160., 40., 50] = -0.010808188239338858 + 0.005593672927007928*I
 
mylNLS[160., 80., 50] = -0.024285177433882994 - 0.01966491662930339*I
 
mylNLS[160., 160., 50] = 0.013604225421184947 + 0.02049759335194174*I
 
mylNLS[160., 320., 50] = 0.009869754500575083 - 0.0036385264691801457*I
 
mylNLS[160., 500., 50] = 0.0014468112488831757 - 0.005390179215247897*I
 
mylNLS[160., 1000., 50] = 0.0002498520569545256 - 0.001993014476308105*I
 
mylNLS[160., 2000., 50] = -0.000043291692268195584 + 0.0007117297563932136*I
 
mylNLS[160., 4000., 50] = 0.0002521950074032963 + 7.56075721155484*^-6*I
 
mylNLS[160., 8000., 50] = 0.00006401607110710091 - 0.00006213890265470006*I
 
mylNLS[320., 1., 50] = -4.1367323270428275*^-8 + 2.8168410518393874*^-7*I
 
mylNLS[320., 2., 50] = 4.4893793719449817*^-7 + 1.0060527246224214*^-6*I
 
mylNLS[320., 3., 50] = 2.185533307630906*^-6 + 2.106249963790101*^-6*I
 
mylNLS[320., 4., 50] = -5.228713235110212*^-6 - 3.3855864557687763*^-6*I
 
mylNLS[320., 5., 50] = 7.597176101234969*^-6 - 7.785460018855908*^-6*I
 
mylNLS[320., 6., 50] = 0.000015917773487373818 + 6.388919454856402*^-6*I
 
mylNLS[320., 8., 50] = -9.868713183042686*^-6 + 0.00003375857447192364*I
 
mylNLS[320., 10., 50] = -0.00005643764836992058 + 0.000024069244936984584*I
 
mylNLS[320., 20., 50] = -0.00007382903652978969 - 0.00033499073675050985*I
 
mylNLS[320., 40., 50] = 0.0010743185344611484 - 0.0015071662031687543*I
 
mylNLS[320., 80., 50] = 0.006638235506223958 - 0.0055142903252651575*I
 
mylNLS[320., 160., 50] = -0.011926524597620683 + 0.018721266795814553*I
 
mylNLS[320., 320., 50] = -0.01718441671306466 - 0.0024083090547852544*I
 
mylNLS[320., 500., 50] = 0.00890649987801188 - 0.0052325936844789984*I
 
mylNLS[320., 1000., 50] = 0.0018697003347872738 - 0.003468841631486542*I
 
mylNLS[320., 2000., 50] = 0.0003384297559153029 - 0.0013783085722624691*I
 
mylNLS[320., 4000., 50] = 0.00005972721673374782 - 0.0005004590767703684*I
 
mylNLS[320., 8000., 50] = -0.000010515692033528684 + 0.0001780652795243364*I
 
mylNLS[500., 1., 50] = -1.6856165483162752*^-8 - 3.426150004025644*^-8*I
 
mylNLS[500., 2., 50] = -2.4195742097019544*^-7 - 1.5771035045551891*^-7*I
 
mylNLS[500., 3., 50] = -1.100249666947245*^-7 - 7.881945972025486*^-7*I
 
mylNLS[500., 4., 50] = 4.646490221870553*^-7 - 1.566039619242069*^-6*I
 
mylNLS[500., 5., 50] = -2.630370555026327*^-6 + 1.1054911384288059*^-6*I
 
mylNLS[500., 6., 50] = 2.9513342378038356*^-6 - 3.397041431056158*^-6*I
 
mylNLS[500., 8., 50] = -7.393013284665538*^-6 + 5.531907083744731*^-6*I
 
mylNLS[500., 10., 50] = -3.213984956475062*^-6 - 0.00001579747634355066*I
 
mylNLS[500., 20., 50] = -0.00005697895819405021 + 0.00007064428931276615*I
 
mylNLS[500., 40., 50] = -0.00022798694914749574 - 0.00044907322697834966*I
 
mylNLS[500., 80., 50] = -0.0011679936899613077 + 0.0023635531712444128*I
 
mylNLS[500., 160., 50] = 0.008442802345843626 + 0.006771224778594893*I
 
mylNLS[500., 320., 50] = 0.01632429718130049 - 0.008609419559121811*I
 
mylNLS[500., 500., 50] = -0.0055997522215356366 - 0.012688582016190494*I
 
mylNLS[500., 1000., 50] = -0.001570717597016536 - 0.005721606035293853*I
 
mylNLS[500., 2000., 50] = -0.00032736959592149443 - 0.002172658543221526*I
 
mylNLS[500., 4000., 50] = 0.00006176042482324245 + 0.0007832687619001095*I
 
mylNLS[500., 8000., 50] = 0.00027832443231829904 - 0.000011229535782543437*I
 
mylNLS[1000., 1., 50] = 3.6380067089207806*^-8 - 8.272780311756756*^-9*I
 
mylNLS[1000., 2., 50] = -2.4353766011654676*^-8 + 2.659226789022474*^-8*I
 
mylNLS[1000., 3., 50] = 8.463746037985949*^-8 - 5.230342013608138*^-8*I
 
mylNLS[1000., 4., 50] = 8.238625904784854*^-8 + 1.8687308402228972*^-7*I
 
mylNLS[1000., 5., 50] = -6.454538796127861*^-9 - 3.567024836789419*^-7*I
 
mylNLS[1000., 6., 50] = -5.412976719545298*^-7 + 1.5388057319901723*^-7*I
 
mylNLS[1000., 8., 50] = -9.677776284537014*^-7 - 6.305582415087364*^-7*I
 
mylNLS[1000., 10., 50] = 1.4129807318706122*^-6 - 1.4401256019140536*^-6*I
 
mylNLS[1000., 20., 50] = -0.00001050370635670905 + 4.429187118339291*^-6*I
 
mylNLS[1000., 40., 50] = -0.00001309483725656221 - 0.00006282647335025243*I
 
mylNLS[1000., 80., 50] = -0.0002182392598698941 + 0.00028143143820704374*I
 
mylNLS[1000., 160., 50] = -0.000968277293372954 - 0.0015936423104453614*I
 
mylNLS[1000., 320., 50] = -0.0013273910741683622 + 0.007548329533171188*I
 
mylNLS[1000., 500., 50] = -0.01204301593635778 + 0.0036939310781254073*I
 
mylNLS[1000., 1000., 50] = -0.008646484895425518 - 0.004611007322925387*I
 
mylNLS[1000., 2000., 50] = -0.0023691734391660113 - 0.0034590505989928843*I
 
mylNLS[1000., 4000., 50] = -0.0004824285446088526 - 0.0014762450878709043*I
 
mylNLS[1000., 8000., 50] = -0.00008950412398944447 - 0.0005482117233540802*I
 
mylNLS[2000., 1., 50] = 9.124349905297556*^-9 - 3.123782605198369*^-9*I
 
mylNLS[2000., 2., 50] = -3.821074120850289*^-9 + 2.2842020023497098*^-10*I
 
mylNLS[2000., 3., 50] = -7.520736312538402*^-9 - 1.0065307138164368*^-8*I
 
mylNLS[2000., 4., 50] = -2.283847841530115*^-9 - 2.5454934961786652*^-8*I
 
mylNLS[2000., 5., 50] = 4.448987567907221*^-8 - 3.1814490930484433*^-9*I
 
mylNLS[2000., 6., 50] = 3.147525348896115*^-8 - 6.291355548410983*^-8*I
 
mylNLS[2000., 8., 50] = -9.743300745943331*^-8 + 1.0659235799093461*^-7*I
 
mylNLS[2000., 10., 50] = -2.5210297872110127*^-7 + 9.0635392790148*^-9*I
 
mylNLS[2000., 20., 50] = -2.6238478249818696*^-8 - 1.4263745419418501*^-6*I
 
mylNLS[2000., 40., 50] = 5.638354649878776*^-6 - 5.7603722408849386*^-6*I
 
mylNLS[2000., 80., 50] = -0.00004172948593593505 + 0.000017831870849054922*I
 
mylNLS[2000., 160., 50] = -0.00005609414873162101 - 0.0002455031435482065*I
 
mylNLS[2000., 320., 50] = -0.0007263253762257163 + 0.001100711617043117*I
 
mylNLS[2000., 500., 50] = -0.0004496990383185658 + 0.0034308130349439084*I
 
mylNLS[2000., 1000., 50] = 0.008755827855266195 + 0.0016716861953043408*I
 
mylNLS[2000., 2000., 50] = -0.004631892831602541 + 0.005149578800729855*I
 
mylNLS[2000., 4000., 50] = -0.0028257860719069256 - 0.000893285408391078*I
 
mylNLS[2000., 8000., 50] = -0.0006626452004370771 - 0.0008754868364500923*I
 
mylNLS[4000., 1., 50] = -1.615825724299812*^-8 + 4.57907414007472*^-9*I
 
mylNLS[4000., 2., 50] = -8.192446903428508*^-10 + 3.637340088484222*^-9*I
 
mylNLS[4000., 3., 50] = -2.204048456317851*^-9 - 1.603753629111351*^-9*I
 
mylNLS[4000., 4., 50] = 3.372880015811274*^-9 - 1.2609947447393775*^-9*I
 
mylNLS[4000., 5., 50] = 5.444852715073313*^-9 - 1.443612796089757*^-9*I
 
mylNLS[4000., 6., 50] = -2.4480295006835268*^-9 + 8.373074616410594*^-9*I
 
mylNLS[4000., 8., 50] = -1.775311781149159*^-8 + 3.203387141296034*^-9*I
 
mylNLS[4000., 10., 50] = 3.121229964390222*^-8 - 4.496662832072316*^-9*I
 
mylNLS[4000., 20., 50] = 1.77919012284318*^-7 - 1.277495610154094*^-8*I
 
mylNLS[4000., 40., 50] = -1.0081031389888194*^-6 + 3.655480544542504*^-8*I
 
mylNLS[4000., 80., 50] = -1.1159412334959748*^-7 - 5.698611906009314*^-6*I
 
mylNLS[4000., 160., 50] = 0.00002233581628304274 - 0.000023038578253153255*I
 
mylNLS[4000., 320., 50] = -0.00016237847018749302 + 0.00007309571312802757*I
 
mylNLS[4000., 500., 50] = 0.00006706805694328688 + 0.000519402921652781*I
 
mylNLS[4000., 1000., 50] = -0.002139326118240638 - 0.0011884266614427654*I
 
mylNLS[4000., 2000., 50] = 0.002506831244381156 + 0.005785773259073951*I
 
mylNLS[4000., 4000., 50] = 0.0045965293606540225 - 0.0016877409375892754*I
 
mylNLS[4000., 8000., 50] = -0.0010940349489803544 + 0.0017869264031486736*I
 
mylNLS[8000., 1., 50] = -6.834423647144732*^-9 - 2.3505368591317786*^-8*I
 
mylNLS[8000., 2., 50] = 9.099757738107383*^-9 - 2.5235938898613775*^-9*I
 
mylNLS[8000., 3., 50] = -3.2063269658679644*^-9 + 2.81339548156342*^-9*I
 
mylNLS[8000., 4., 50] = 3.639092182163104*^-10 - 2.397726696565781*^-9*I
 
mylNLS[8000., 5., 50] = 1.3820919933147345*^-9 - 5.388406364373734*^-10*I
 
mylNLS[8000., 6., 50] = 2.542237830771804*^-10 + 3.9323601200378505*^-10*I
 
mylNLS[8000., 8., 50] = 1.6054101438262459*^-9 - 1.2820115194026792*^-9*I
 
mylNLS[8000., 10., 50] = 3.2295031669521065*^-9 - 2.12826008118977*^-9*I
 
mylNLS[8000., 20., 50] = 2.139527200295966*^-8 - 6.293910725739928*^-9*I
 
mylNLS[8000., 40., 50] = 1.2483916037313476*^-7 - 1.7998466343292947*^-8*I
 
mylNLS[8000., 80., 50] = 7.114531256937327*^-7 - 5.130866329185581*^-8*I
 
mylNLS[8000., 160., 50] = -4.027492002798942*^-6 + 1.5079600041237057*^-7*I
 
mylNLS[8000., 320., 50] = -5.528411018911701*^-7 - 0.000022683180670798756*I
 
mylNLS[8000., 500., 50] = 0.00006596637296446832 - 0.000018861171812857677*I
 
mylNLS[8000., 1000., 50] = -0.0003633861901228216 + 0.00007137127350406226*I
 
mylNLS[8000., 2000., 50] = 0.0005295184977710484 + 0.0016476732644110652*I
 
mylNLS[8000., 4000., 50] = -0.004457115916744468 + 0.00014583816855465517*I
 
mylNLS[8000., 8000., 50] = 0.0028147798410622284 + 0.0020156520390843917*I
 
mylNLS[x_, t_, n_] := mylNLS[x, t, n] = Module[{l1, dlt, s0}, 
      l1 = 30; dlt = 0.5*I; s0 = x/2/t; f1dtrundom1 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0 + dlt - Abs[dlt] - l1, s0 + dlt - Abs[dlt]}], n}]; 
       f1dtrundom2 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0 + dlt - Abs[dlt], s0}], n/2}]; f1dtrundom3 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[#1] & , 
          Line[{s0, s0 + dlt - Abs[dlt] + l1 - l1*I}], n/2}]; 
       f1d1 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom1, n*3]; 
       f1d2 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom2, n]; 
       f1d3 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[#1] & , f1dtrundom3, n]; 
       I1 = 0; If[f1d1 != {}, I1 = I1 + DomainIntegrate[f1d1]/2/Pi]; 
       If[f1d2 != {}, I1 = I1 + DomainIntegrate[f1d2]/2/Pi]; 
       If[f1d3 != {}, I1 = I1 + DomainIntegrate[f1d3]/2/Pi]; 
       f2btrundom1 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0 - dlt + Abs[dlt] - l1 + l1*I, s0}], n/2}]; 
       f2btrundom2 = Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0, s0 - dlt + Abs[dlt]}], n/2}]; f2btrundom3 = 
        Truncate[tol][{Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , 
          Line[{s0 - dlt + Abs[dlt], s0 - dlt + Abs[dlt] + l1}], n}]; 
       f2b1 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom1, n]; 
       f2b2 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom2, n]; 
       f2b3 = Fun[Exp[\[Theta][#1, x, t]]*q0h1[-#1] & , f2btrundom3, n*2]; 
       I2 = 0; If[f2b1 != {}, I2 = I2 + -DomainIntegrate[f2b1]/2/Pi]; 
       If[f2b2 != {}, I2 = I2 + -DomainIntegrate[f2b2]/2/Pi]; 
       If[f2b3 != {}, I2 = I2 + -DomainIntegrate[f2b3]/2/Pi]; 
       p = 2*(Log[tol]/(-x)); f3bbtrundom1a = Truncate[tol][
         {Abs[Exp[I*#1*x]*g0h1[#1, t]*#1] & , Line[{-p + p*I + s0*I, s0*I}], 
          n}]; f3bbtrundom2 = Truncate[tol][
         {Abs[Exp[\[Theta][#1, x, t]]*g0t1[#1, Infinity]*#1] & , 
          Line[{s0*I, s0}], n}]; f3bb = 
        Join[Fun[Exp[I*#1*x]*g0h1[#1, t]*#1 & , f3bbtrundom1a, n], 
         Fun[Exp[\[Theta][#1, x, t]]*g0t1[#1, Infinity]*#1 & , f3bbtrundom2, 
          n]]; I3a = DomainIntegrate[f3bb]/Pi; f3ctrundom2 = 
        Truncate[tol][{Abs[Exp[I*#1*x - I*#1^2*t]*g0t2[#1, t]*#1] & , 
          Line[{s0*I + l1*I, s0*I}], n}]; 
       f3c = Join[Fun[Exp[I*#1*x - I*#1^2*t]*g0t2[#1, t]*#1 & , f3ctrundom2, 
          n]]; I3c = If[f3c != {}, DomainIntegrate[f3c]/Pi, 0]; 
       g3[xx_, tt_][k_] := I*k*xx - I*tt*k^2; g3[xx_, tt_][_?InfinityQ] := 0; 
       dg3[xx_, tt_][k_] := I*xx - 2*I*k*tt; dg3[xx_, tt_][_?InfinityQ] := 0; 
       g0texactk[tt_][k_] := g0t1[k, Infinity]*k; 
       g0texactk[tt_][_?InfinityQ] := 0; 
       iii = LevinInt[g0texactk[t], g3[x, t], dg3[x, t], s0, Infinity, n*2, 
          1, False]/Pi; I1 + I2 + I3a + I3c + iii]
 
x = 1.
 
t = 1000.
 
f1dtrundom1 = {}
 
Truncate[tol_][{F_, Domain_, n_}] := Module[{f1, vals, x0, dx, i, Change, 
      n0}, dx = 0.025; n0 = 100; f1 = Fun[0 & , Domain, n]; 
      vals = Table[{Abs[F[MapFromInterval[f1, x0]]] - tol, 
         MapFromInterval[f1, x0]}, {x0, -1, 1, 2/n0}]; Change = {}; 
      If[Abs[F[MapFromInterval[f1, -1]]] - tol > 0, 
       Change = {{MapFromInterval[f1, -1], 1}}; ]; 
      For[i = 1, i <= Length[vals] - 1, i++, 
       If[SignChange[vals[[i,1]], vals[[i + 1,1]]], 
        Change = Join[Change, {{If[Sign[vals[[i + 1,1]]] == 1, vals[[i,2]], 
              vals[[i + 1,2]]], Sign[vals[[i + 1,1]]]}}]; ]]; 
      If[Change != {} && Change[[-1]][[2]] == 1, 
       Change = Join[Change, {{MapFromInterval[f1, 1], -1}}]; ]; 
      CreateDomains[Change]]
 
Truncate /: Truncate::usage = "Contour truncation routine.  This requires the \
sample function, see Setrsamp[]."
 
tol = 1.*^-12
 
Domain[IFun[_List, Private`d_]] := Private`d
 
Domain[LFun[_, Private`d_]] := Private`d
 
Domain[PFun[_, Private`d_]] := Private`d
 
Domain[Private`if_SingFun] := Domain[First[Private`if]]
 
Domain /: Domain::usage = "Domain[ifun] returns the domain of an IFun."
 
IFun[Private`l_List, Private`d_][Private`z_] := 
    Private`ChebyshevLobattoBarycentricInterpolation[Private`l, 
     MapToInterval[Private`d, Private`z]]
 
Values[IFun[Private`l_List, _]] ^:= Private`l
 
(Private`f$_) /@ (Private`g$_IFun) ^:= IFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_IFun] ^:= Length[Values[Private`if]]
 
(Private`f_IFun) + (Private`g_IFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_IFun)*(Private`g_IFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_IFun) + (Private`f$_)?ConstantQ ^:= 
    IFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_IFun)*(Private`f$_)?ConstantQ ^:= 
    IFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_IFun)^(Private`c$_)?ConstantQ ^:= 
    IFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_IFun) ^:= 
    IFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_IFun)?ArrayFunQ . (Private`g_IFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
IFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_IFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_IFun] ^:= IFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_IFun] ^:= IFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_IFun] ^:= IFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_IFun] ^:= IFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_IFun] ^:= IFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_IFun] ^:= IFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_IFun] ^:= IFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_IFun] ^:= IFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_IFun] ^:= IFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_IFun] ^:= IFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_IFun] ^:= IFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_IFun] ^:= IFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_IFun] ^:= IFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_IFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_IFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_IFun] ^:= Transpose /@ Private`f
 
Max[Private`f_IFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_IFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_IFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_IFun] ^:= First[Values[Private`f]]
 
Last[Private`f_IFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_IFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_IFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_IFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_IFun] ^:= DCT[Private`f][[1]]
 
Derivative[(Private`k_)?Positive][(Private`f_IFun)?ArrayFunQ] ^:= 
    ToArrayFun[ArrayMap[Derivative[Private`k], ToArrayOfFuns[Private`f]]]
 
Derivative[0][Private`if_IFun] ^:= Private`if
 
Derivative[1][Private`if_IFun] ^:= 
    IFun[ChebyshevLobattoDerivative[Values[Private`if]], Domain[Private`if]]*
     IFun[MapToIntervalD[Private`if, #1] & , Domain[Private`if], 
      Length[Private`if]]
 
Derivative[(Private`k_)?Positive][Private`if_IFun] ^:= 
    Derivative[1][Derivative[Private`k - 1][Private`if]]
 
Derivative[Private`if_IFun] ^:= Derivative[1][Private`if]
 
Integrate[Private`if_IFun] ^:= IFun[ChebyshevLobattoIntegrate[
      Values[Private`if]*Values[IFun[MapFromIntervalD[Private`if, #1] & , 
         UnitInterval, Length[Private`if]]]], Domain[Private`if]]
 
DiagonalMatrix[Private`f_IFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_IFun] ^:= IdentityMatrix[Length[Private`f]]
 
Roots[Private`cf_IFun] ^:= MapFromInterval[Private`cf, 
     Sort[Re[Select[ComplexRoots[ToUnitInterval[Private`cf]], 
        Abs[Im[#1]] < 100*$MachineTolerance && -1. <= Re[#1] <= 1. & ]]]]
 
Minimize[Private`cf_IFun] ^:= 
    Second[First[Sort[(Thread[{Abs[Private`cf /@ #1], #1}] & )[
        Join[Roots[Derivative[1][Private`cf]], Endpoints[Private`cf]]]]]]
 
IFun[(Private`f_)?NotListOrPatternQ, Private`d_, Private`n_Integer] := 
    IFun[Private`f /@ IntervalPoints[Private`d, Private`n], Private`d]
 
IFun[Private`a_] := IFun[Private`a, UnitInterval]
 
IFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts:OptionsPattern[]] := Private`AdaptiveIFun[4, Private`f, 
     Private`d, Private`opts]
 
MakeBoxes[Private`f:IFun[Private`l_List, _], FormatType_] ^:= 
    Format[ReImLinePlot[Private`f, Sequence @@ $FunFormat], FormatType]
 
Format[Private`f:IFun[Private`l_List, _]] := ReImLinePlot[Private`f, 
     Sequence @@ $FunFormat]
 
Options[IFun] := {InterpolationPrecision -> $MachineTolerance}
 
IFun /: IFun::usage = "IFun[\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\
,d,n] constructs an \!\(\*\nStyleBox[\"n\",\nFontSlant->\"Italic\"]\)-th \
order Chebyshev approximation of \
\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\) over the domain d, which is \
either a Line or \
Arc\!\(\*\nStyleBox[\".\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)IFun\!\(\*\nStyleBox[\"[\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\",\",\
\nFontSlant->\"Italic\"]\)d\!\(\*\nStyleBox[\"]\",\nFontSlant->\"Italic\"]\)\
\!\(\*\nStyleBox[\" \",\nFontSlant->\"Italic\"]\)chooses n adaptively. \
\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)IFun\!\(\*\nStyleBox[\"[\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\",\",\
\nFontSlant->\"Italic\"]\)d\!\(\*\nStyleBox[\",\",\nFontSlant->\"Italic\"]\)I\
nterpolationPrecision\[Rule]tol] chooses n adaptively, so that the last two \
Chebyshev coefficients are less than tol. If f is a constructed IFun, then \
f[x] evaluates the approximation at the point x. Operations that can be \
applied to an IFun include standard mathematical functions (Abs, Sin, Exp, \
etc.) and operators Integrate (returning the indefinite integral) and \
Derivative[k]."
 
Private`ChebyshevLobattoBarycentricInterpolation[Private`f_List, 
     Private`x_] := Module[{Private`w, Private`j, Private`p, Private`k, 
      Private`n}, Private`k = Length[Private`f]; 
      Private`n = NChebyshevLobattoPoints[Private`k]; Private`w[1] = 1/2; 
      Private`w[Private`j_] = (-1)^(Private`j + 1); Private`w[Private`k] = 
       ((-1)^(Private`k + 1)*1)/2; If[MemberQ[Private`n, 
        N[Chop[Private`x, $MachineEpsilon]]], Private`f[[
        Position[Private`n, N[Chop[Private`x, $MachineEpsilon]]][[1,1]]]], 
       Sum[(Private`w[Private`j]/(Private`x - Private`n[[Private`j]]))*
          Private`f[[Private`j]], {Private`j, 1, Private`k}]/
        Sum[Private`w[Private`j]/(Private`x - Private`n[[Private`j]]), 
         {Private`j, 1, Private`k}]]]
 
NChebyshevLobattoPoints[Private`n_, Private`a_:-1., Private`b_:1.] := 
    0.5*(Private`b + Private`a) + 0.5*(Private`b - Private`a)*
      Cos[(Pi*Range[Private`n - 1., 0., -1.])/(Private`n - 1)]
 
Attributes[MapToInterval] = {Listable}
 
MapToInterval[Line[{_?InfinityQ, _?InfinityQ}], Private`y_] := 
    RealLineToInterval[Private`y]
 
MapToInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`z_] := HalfLineToInterval[
     (Exp[-(I*Arg[Private`b])]*(Private`z - Private`a))/Private`L]
 
MapToInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`z_] := 
    -MapToInterval[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      Private`z]
 
MapToInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`z_] := MapToInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`z_] := MapToInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToInterval[Line[{Private`a_, Private`b_}], Private`z_] := 
    (Private`a + Private`b - 2*Private`z)/(Private`a - Private`b)
 
MapToInterval[Private`z_] := Private`z
 
MapToInterval[Line[{Private`a_, Private`b_}, 
      Stretch -> _?(NEqual[1., #1] & )], _?InfinityQ] := Infinity
 
MapToInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     _?InfinityQ] := (1 + Private`L)/(1 - Private`L)
 
MapToInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (-Private`a - Private`b*Private`L + 
      (1 + Private`L)*Private`z)/(-Private`a + Private`b*Private`L + 
      Private`z - Private`L*Private`z)
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
      Private`z_] /; NEqual[-(E^((1*I*(Private`t0 + Private`t1))/2)*
         Private`r) + Private`z0, Private`z] := Infinity
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     _?InfinityQ] := -((E^((I*Private`t0)/2) + E^((I*Private`t1)/2))/
      (E^((I*Private`t0)/2) - E^((I*Private`t1)/2)))
 
MapToInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`z_] := -(((E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
       (E^((I*Private`t0)/2 + (I*Private`t1)/2)*Private`r - Private`z + 
        Private`z0))/((-E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
       (E^((I*Private`t0)/2 + (I*Private`t1)/2)*Private`r + Private`z - 
        Private`z0)))
 
MapToInterval[Private`f_IFun, Private`z_] := MapToInterval[Domain[Private`f], 
     Private`z]
 
MapToInterval[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapToInterval[Curve[Private`cr_], Private`z_] /; NEqual[Private`z, 
      First[Private`cr]] := -1.
 
MapToInterval[Curve[Private`cr_], Private`z_] /; NEqual[Private`z, 
      Last[Private`cr]] := 1.
 
MapToInterval[Curve[Private`cr_], Private`z_] := 
    (If[#1 == {}, {}, First[#1]] & )[Roots[Private`cr - Private`z]]
 
MapToInterval[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapToInterval[Line[{-1, 1}, Stretch -> Private`L], 
     MapToInterval[Curve[Private`cr], Private`z]]
 
MapToInterval /: MapToInterval::usage = "MapToInterval[d,x] maps the point x \
via the conformal map that maps the domain d to the unit interval. If d is an \
IFun, then it is equivalent to MapToInterval[Domain[d],x]."
 
InfinityQ[-Infinity] := True
 
InfinityQ[Infinity] := True
 
InfinityQ[_DirectedInfinity] := True
 
InfinityQ[_] := False
 
InfinityQ /: InfinityQ::usage = "Test for whether a value is infinite."
 
Attributes[RealLineToInterval] = {Listable}
 
RealLineToInterval[(Private`y_)?NumberQ] := Private`y/Sqrt[1 + Private`y^2]
 
Stretch /: Stretch::usage = "Stretch is a possible parameter for Line used in \
determining the conformal map."
 
Attributes[HalfLineToInterval] = {Listable}
 
HalfLineToInterval[(Private`y_)?InfinityQ] := 1.
 
HalfLineToInterval[Private`y_] /; Private`y == -1 := Infinity
 
HalfLineToInterval[Private`y_] := (-1 + Private`y)/(1 + Private`y)
 
NEqual[Private`f:{__?FunQ}, Private`g:{__?FunQ}] := 
    Norm[Norm /@ (Private`f - Private`g)] < $MachineTolerance
 
NEqual[Private`f_List, Private`g_List] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[_?InfinityQ, _?InfinityQ] := True
 
NEqual[Private`f_IFun, Private`g_IFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Line[Private`ls_, ___], Line[Private`ls2_, ___]] := 
    NZeroQ[Max[Abs[Flatten[(If[#1[[1]] == #1[[2]], 0, 
           #1[[1]] - #1[[2]]] & ) /@ Thread[{Sort[Private`ls], 
           Sort[Private`ls2]}]]]]]
 
NEqual[Arc[Private`x0_, Private`r_, Private`t0_], 
     Arc[Private`x2_, Private`r2_, Private`t2_]] := 
    NZeroQ[Max[Abs[Flatten[{Private`x0 - Private`x2, Private`r - Private`r2, 
         Exp[I*Private`t0] - Exp[I*Private`t2]}]]]]
 
NEqual[Private`f_LFun, Private`g_LFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Private`f_PFun, Private`g_PFun] := Norm[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual[Curve[Private`f_, Private`opts___], Curve[Private`g_, 
      Private`opts___]] := If[Length[Private`f] == Length[Private`g], 
     Norm[Values[Private`f - Private`g]] < $MachineTolerance, False]
 
NEqual[Private`f_SingFun, Private`g_SingFun] := 
    Norm[Values[Private`f - Private`g]] < $MachineTolerance
 
NEqual[Private`f_, Private`g_] := Abs[Private`f - Private`g] < 
     $MachineTolerance
 
NEqual /: NEqual::usage = "NEqual[i,j] determines whether two values are \
within $MachineTolerence of each other."
 
FunQ[_IFun] := True
 
FunQ[_LFun] := True
 
FunQ[_PFun] := True
 
FunQ[_] := False
 
FunQ /: FunQ::usage = "Tests if an object is in IFun or LFun."
 
LFun[Private`l_List, Private`d_][Private`z_] := 
    MapDot[MapToCircle[Private`d, Private`z]^#1 & , FFT[Private`l]]
 
Values[LFun[Private`l_List, _]] ^:= Private`l
 
(Private`f$_) /@ (Private`g$_LFun) ^:= LFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_LFun] ^:= Length[Values[Private`if]]
 
(Private`f_LFun) + (Private`g_LFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_LFun)*(Private`g_LFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_LFun) + (Private`f$_)?ConstantQ ^:= 
    LFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_LFun)*(Private`f$_)?ConstantQ ^:= 
    LFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_LFun)^(Private`c$_)?ConstantQ ^:= 
    LFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_LFun) ^:= 
    LFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_LFun)?ArrayFunQ . (Private`g_LFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
LFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_LFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_LFun] ^:= LFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_LFun] ^:= LFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_LFun] ^:= LFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_LFun] ^:= LFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_LFun] ^:= LFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_LFun] ^:= LFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_LFun] ^:= LFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_LFun] ^:= LFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_LFun] ^:= LFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_LFun] ^:= LFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_LFun] ^:= LFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_LFun] ^:= LFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_LFun] ^:= LFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_LFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_LFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_LFun] ^:= Transpose /@ Private`f
 
Max[Private`f_LFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_LFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_LFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_LFun] ^:= First[Values[Private`f]]
 
Last[Private`f_LFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_LFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_LFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_LFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_LFun] ^:= FFT[Private`f][[0]]
 
Derivative[0][Private`if_LFun] ^:= Private`if
 
Derivative[1][Private`f_LFun] ^:= 
    (#1*LFun[MapToCircleD[Private`f, #1] & , Domain[Private`f], 
        Length[#1]] & )[LFun[InverseFFT[PadRight[
        ShiftLeft[MapOuter[#1 & , FFT[Private`f]]], Length[Private`f] + 2]], 
      Domain[Private`f]]]
 
Derivative[(Private`k_)?Positive][Private`if_LFun] ^:= 
    Derivative[1][Derivative[Private`k - 1][Private`if]]
 
Derivative[Private`if_LFun] ^:= Derivative[1][Private`if]
 
Integrate[Private`lf_LFun, Private`z_] ^:= 
    BoundedIntegrate[Private`lf][Private`z] + DomainIntegrate[Private`lf]*
      (Log[MapToCircle[Private`lf, Private`z]]/(2*Pi*I) - 
       Piecewise[{{-2^(-1), NEqual[MapToCircle[Private`lf, Infinity], -1]}, 
         {Log[MapToCircle[Private`lf, Infinity]]/(2*Pi*I), True}}])
 
Reverse[Private`lf:LFun[_, Line[{-Infinity, Infinity}, ___]]] ^:= 
    LFun[Join[{Values[Private`lf][[1]]}, Reverse[Rest[Values[Private`lf]]]], 
     Domain[Private`lf]]
 
DiagonalMatrix[Private`f_LFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_LFun] ^:= IdentityMatrix[Length[Private`f]]
 
Roots[Private`lf_LFun] ^:= Module[{Private`dct}, 
     Private`dct = ToList[RemoveZeros[Chop[FFT[Private`lf], 
          $MachineTolerance]]]; MapFromCircle[Private`lf, 
       Select[Eigenvalues[Transpose[Join[Transpose[SparseArray[
             {Private`i_, Private`j_} /; Private`j == Private`i - 1 -> 1, 
             {Length[Private`dct] - 1, Length[Private`dct] - 2}]], 
           -({Most[Private`dct]}/Last[Private`dct])]]], 
        Abs[Abs[#1] - 1] < 10.^(-6) & ]]]
 
LFun /: ToeplitzMatrix[Private`lf_LFun, Private`n_Integer] := 
     ToeplitzMatrix[FFT[Private`lf], Private`n]
 
LFun /: HankelMatrix[Private`lf_LFun, Private`n_Integer] := 
     HankelMatrix[FFT[Private`lf], Private`n]
 
LFun[Private`f_, Private`d_, Private`n_] := 
    LFun[Private`f /@ MapFromCircle[Private`d, Points[UnitCircle, 
        Private`n]], Private`d]
 
LFun[Private`l_ShiftList, Private`d_] := 
    LFun[InverseFFT[MakeFFTIndexRange[Private`l]], Private`d]
 
LFun[Private`f_IFun] := LFun[Join[Values[Private`f], 
      Reverse[Values[Private`f]][[2 ;; -2]]], UnitCircle]
 
LFun[Private`a_] := LFun[Private`a, UnitCircle]
 
LFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts:OptionsPattern[]] := Private`AdaptiveLFun[8, Private`f, 
     Private`d, Private`opts]
 
MakeBoxes[Private`f:LFun[Private`l_List, _], FormatType_] ^:= 
    Format[ReImLinePlot[Private`f, Sequence @@ $FunFormat], FormatType]
 
Format[Private`f:LFun[Private`l_List, _]] := ReImLinePlot[Private`f, 
     Sequence @@ $FunFormat]
 
Options[LFun] := {InterpolationPrecision -> $MachineTolerance}
 
LFun /: LFun::usage = "LFun[\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\)\
,d,n] constructs an \!\(\*\nStyleBox[\"n\",\nFontSlant->\"Italic\"]\)-th \
order Laurent approximation of \
\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\) over the domain d, which is \
either a Circle or the real line \
Line[{-\[Infinity],\[Infinity]}]\!\(\*\nStyleBox[\".\",\nFontSlant->\"Italic\
\"]\)\!\(\*\nStyleBox[\"  \",\nFontSlant->\"Italic\"]\)If f is a constructed \
LFun, then\!\(\*\nStyleBox[\" \
\",\nFontSlant->\"Italic\"]\)\!\(\*\nStyleBox[\"f\",\nFontSlant->\"Italic\"]\
\)[x] evaluates the approximation at the point x. Operations that can be \
applied to an LFun include standard mathematical functions (Abs,Sin,Exp,etc.) \
and operators Integrate (returning the indefinite integral) and \
Derivative[k]."
 
MapDot[Private`f_, Private`ls_List] := Module[{Private`k}, 
     Sum[Private`ls[[Private`k]]*Private`f[Private`k], 
      {Private`k, 1, Length[Private`ls]}]]
 
MapDot[Private`m_, Private`lst_ShiftList] := Module[{Private`k}, 
     Sum[Private`lst[[Private`k]]*Private`m[Private`k], 
      {Private`k, FirstIndex[Private`lst], LastIndex[Private`lst]}]]
 
Attributes[ShiftList] = {NHoldRest}
 
ShiftList[Private`ln_List, Private`ind_Integer][[Private`j_]] ^:= 
    Private`ln[[Private`fixind[Private`j, Private`ind, Length[Private`ln]]]]
 
Length[Private`l_ShiftList] ^:= Length[ToList[Private`l]]
 
Drop[Private`l_ShiftList, Private`n_] ^:= 
    ShiftList[Drop[ToList[Private`l], Private`n], Index[Private`l] - 
      Private`n]
 
(Private`ln_ShiftList) + (Private`ln2_ShiftList) ^:= 
    Module[{Private`lnn, Private`lnn2}, 
     Private`lnn = IncreaseIndexRange[Private`ln, IndexRange[Private`ln2]]; 
      Private`lnn2 = IncreaseIndexRange[Private`ln2, IndexRange[Private`ln]]; 
      ShiftList[ToList[Private`lnn] + ToList[Private`lnn2], 
       Index[Private`lnn]]]
 
(Private`c_) + ShiftList[Private`ln_, Private`ind_] ^:= 
    ShiftList[Private`ln + Private`c, Private`ind]
 
(Private`sl1_ShiftList) . (Private`sl2_ShiftList) ^:= 
    Module[{Private`indm, Private`indM}, 
     Private`indm = Max[FirstIndex[Private`sl1], FirstIndex[Private`sl2]]; 
      Private`indM = Min[LastIndex[Private`sl1], LastIndex[Private`sl2]]; 
      If[Private`indM < Private`indm, 0, 
       Private`sl1[[Private`indm ;; Private`indM]] . 
        Private`sl2[[Private`indm ;; Private`indM]]]]
 
ShiftList[Private`ln_, Private`ind_]*ShiftList[Private`ln2_, 
      Private`ind_] ^:= ShiftList[Private`ln*Private`ln2, Private`ind]
 
(Private`c_)*ShiftList[Private`ln_, Private`ind_] ^:= 
    ShiftList[Private`c*Private`ln, Private`ind]
 
ListConvolve[Private`a_ShiftList, Private`b_ShiftList, Private`opts___] ^:= 
    ShiftList[ListConvolve[ToList[Private`a], ToList[Private`b], 
      Private`opts], Index[Private`a]]
 
RotateLeft[Private`a_ShiftList, Private`opts___] ^:= 
    ShiftList[RotateLeft[ToList[Private`a], Private`opts], Index[Private`a]]
 
PadRight[Private`f_ShiftList, Private`n_] ^:= 
    ShiftList[PadRight[ToList[Private`f], Private`n, 
      {If[Length[Private`f] == 0, 0, ToList[Private`f][[1]]*0]}], 
     Index[Private`f]]
 
PadLeft[Private`f_ShiftList, Private`n_] ^:= 
    ShiftList[PadLeft[ToList[Private`f], Private`n, 
      {If[Length[Private`f] == 0, 0, ToList[Private`f][[1]]*0]}], 
     Index[Private`f] + Private`n - Length[Private`f]]
 
Append[Private`f_ShiftList, Private`el_] ^:= 
    ShiftList[Append[ToList[Private`f], Private`el], Index[Private`f]]
 
Riffle[Private`sl_ShiftList, Private`x_] ^:= 
    ShiftList[Riffle[ToList[Private`sl], Private`x], Index[Private`sl]*2 - 1]
 
Reverse[Private`sl_ShiftList] ^:= ShiftList[Reverse[ToList[Private`sl]], 
     Length[Private`sl] - Index[Private`sl] + 1]
 
MatrixForm[ShiftList[Private`l_, Private`ind_Integer]] ^:= 
    MatrixForm[Join[Private`l[[1 ;; Private`ind - 1]], 
      {Style[Private`l[[Private`ind]], Bold]}, 
      Private`l[[Private`ind + 1 ;; -1]]]]
 
(Private`f_) @@ ShiftList[Private`l_, _] ^:= Private`f @@ Private`l
 
(Private`f_) /@ ShiftList[Private`l_, Private`ind_] ^:= 
    ShiftList[Private`f /@ Private`l, Private`ind]
 
MapIndexed[Private`f_, ShiftList[Private`ln_, Private`ind_]] ^:= 
    ShiftList[MapIndexed[Private`f[#1, #2 - Private`ind] & , Private`ln], 
     Private`ind]
 
ReplacePart[Private`sl_ShiftList, Private`pat_] ^:= 
    ShiftList[MapIndexed[
      If[Or @@ Function[Private`pm, MatchQ[First[#2] - Index[Private`sl], 
            Private`pm]] /@ First /@ Private`pat, 
        First[#2] - Index[Private`sl] /. Private`pat, #1] & , 
      ToList[Private`sl]], Index[Private`sl]]
 
Abs[Private`f_ShiftList] ^:= Abs /@ Private`f
 
Re[Private`f_ShiftList] ^:= Re /@ Private`f
 
Im[Private`f_ShiftList] ^:= Im /@ Private`f
 
Indices[Private`sl_ShiftList] ^:= Array[#1 - Index[Private`sl] & , 
     Length[Private`sl]]
 
Private`LinePlot[Private`sl_ShiftList, Private`opts___] ^:= 
    ListLinePlot[Thread[{Indices[Private`sl], ToList[Private`sl]}], 
     Private`opts]
 
ListLogPlot[Private`sl_ShiftList, Private`opts___] ^:= 
    ListLogPlot[Thread[{Indices[Private`sl], ToList[Private`sl]}], 
     Private`opts]
 
ShiftList /: ToeplitzMatrix[Private`sl_ShiftList, Private`n_Integer] := 
     Transpose[ToeplitzMatrix[PadRight[Reverse[NonPositiveList[Private`sl]], 
        Private`n], PadRight[NonNegativeList[Private`sl], Private`n]]]
 
ToeplitzMatrix[Private`sl_ShiftList] ^:= ToeplitzMatrix[Private`sl, 
     Length[Private`sl]]
 
ShiftList /: HankelMatrix[Private`sl_ShiftList, Private`n_Integer] := 
     Transpose[HankelMatrix[PadRight[PositiveList[Private`sl], Private`n]]]
 
ShiftList[Private`ln_List, Private`lp_List] := 
    ShiftList[Join[Private`ln, Private`lp], Length[Private`ln] + 1]
 
MakeBoxes[ShiftList[Private`l_, Private`ind_Integer], FormatType_] ^:= 
    Format[If[0 < Private`ind < Length[Private`l], 
      Join[Private`l[[1 ;; Private`ind - 1]], 
       {Style[Private`l[[Private`ind]], Bold]}, 
       Private`l[[Private`ind + 1 ;; -1]]], Private`l], FormatType]
 
Format[ShiftList[Private`l_, Private`ind_Integer]] := 
    If[0 < Private`ind < Length[Private`l], 
     Join[Private`l[[1 ;; Private`ind - 1]], 
      {Style[Private`l[[Private`ind]], Bold]}, 
      Private`l[[Private`ind + 1 ;; -1]]], Private`l]
 
Private`fixind[Private`a_Integer, Private`ind_] := Private`a + Private`ind
 
Private`fixind[All, Private`ind_] := All
 
Private`fixind[All ;; (Private`b_Integer), Private`ind_] := 
    1 ;; Private`b + Private`ind
 
Private`fixind[(Private`a_Integer) ;; (Private`b_Integer), Private`ind_] := 
    Private`a + Private`ind ;; Private`b + Private`ind
 
Private`fixind[(Private`a_Integer) ;; All, Private`ind_] := 
    Private`a + Private`ind ;; All
 
Private`fixind[All ;; All, Private`ind_] := 1 ;; All
 
Private`fixind[Private`a_Integer, Private`ind_, Private`n_] := 
    Mod[Private`a + Private`ind - 1, Private`n] + 1
 
Private`fixind[All, Private`ind_, Private`n_] := All
 
Private`fixind[All ;; (Private`b_Integer), Private`ind_, Private`n_] := 
    1 ;; Private`fixind[Private`b, Private`ind, Private`n]
 
Private`fixind[(Private`a_Integer) ;; (Private`b_Integer), Private`ind_, 
     Private`n_] := Private`fixind[Private`a, Private`ind, Private`n] ;; 
     Private`fixind[Private`b, Private`ind, Private`n]
 
Private`fixind[(Private`a_Integer) ;; All, Private`ind_, Private`n_] := 
    Private`fixind[Private`a, Private`ind, Private`n] ;; All
 
Private`fixind[All ;; All, Private`ind_, Private`n_] := 1 ;; All
 
ToList[ShiftList[Private`ln_, _]] := Private`ln
 
ToList[Private`ln_List] := Private`ln
 
Index[ShiftList[_, Private`ind_]] := Private`ind
 
IncreaseIndexRange[Private`sl_ShiftList, Private`ind_] := 
    Module[{Private`sl2}, Private`sl2 = PadLeft[Private`sl, 
        Length[Private`sl] + Max[0, FirstIndex[Private`sl] - 
           First[Private`ind]]]; PadRight[Private`sl2, 
       Length[Private`sl2] + Max[0, Last[Private`ind] - 
          LastIndex[Private`sl]]]]
 
FirstIndex[Private`l_ShiftList] := 1 - Index[Private`l]
 
LastIndex[Private`l_ShiftList] := Length[Private`l] - Index[Private`l]
 
IndexRange[Private`l_ShiftList] := {FirstIndex[Private`l], 
     LastIndex[Private`l]}
 
NonPositiveList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[1 ;; Private`ind]]
 
NonNegativeList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[Private`ind ;; -1]]
 
PositiveList[ShiftList[Private`ln_, Private`ind_]] := 
    Private`ln[[Private`ind + 1 ;; -1]]
 
Attributes[MakeBoxes] = {HoldAllComplete}
 
Attributes[MapToCircle] = {Listable}
 
MapToCircle[Circle[Private`a_, Private`r_], Private`z_] := 
    (Private`z - Private`a)/Private`r
 
MapToCircle[Circle[Private`a_, Private`r_, Orientation -> 1], Private`z_] := 
    (Private`z - Private`a)/Private`r
 
MapToCircle[Circle[Private`a_, Private`r_, Orientation -> -1], Private`z_] := 
    Private`r/(Private`z - Private`a)
 
MapToCircle[Line[{-Infinity, Infinity}], _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}], _?(NEqual[#1, -I] & )] := Infinity
 
MapToCircle[Line[{-Infinity, Infinity}], Private`t_] := 
    (I - Private`t)/(I + Private`t)
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`t_] := (I - Private`L*Private`t)/(I + Private`L*Private`t)
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], Private`t_] := 
    (I - Private`L*(Private`t - Private`a))/
     (I + Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`t_] := 
    (I + I*Private`L*(Private`t - Private`a))/
     (I - I*Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], _?InfinityQ] := -1.
 
MapToCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`t_] := 
    (I - I*Private`L*(Private`t - Private`a))/
     (I + I*Private`L*(Private`t - Private`a))
 
MapToCircle[Line[{-Pi, Pi}], Private`z_] := Exp[I*Private`z]
 
MapToCircle[Private`l_Line, Private`z_] := 
    MapToCircle[Private`PeriodicInterval, MapToInterval[Private`l, Private`z]*
      Pi]
 
MapToCircle[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapToCircle[Circle[0, Private`r], IntervalToInnerCircle[
      MapToInterval[Line[{Private`a, Private`b}], Private`z]]]
 
MapToCircle[Private`f_LFun, Private`z_] := MapToCircle[Domain[Private`f], 
     Private`z]
 
MapToCircle[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapToCircle[Curve[Private`cr_], Private`z_] := 
    First[Roots[Private`cr - Private`z]]
 
MapToCircle /: MapToCircle::usage = "MapToCircle[d,z] maps z via the \
conformal map from the domain d to the unit circle."
 
Centre /: Centre::usage = "Centre is a possible parameter for Line used in \
determining the conformal map."
 
Private`PeriodicInterval = Line[{-Pi, Pi}]
 
Ellipse[Private`r_] := Ellipse[{-1, 1}, Private`r]
 
Ellipse /: Ellipse::usage = "Ellipse[{a_,b_},r] represents the Bernstein \
ellipse arond the interval (a,b)."
 
Attributes[IntervalToInnerCircle] = {Listable}
 
IntervalToInnerCircle[(Private`t_)?InfinityQ] := 0
 
IntervalToInnerCircle[Private`t_] := Private`t - Sqrt[Private`t - 1]*
      Sqrt[Private`t + 1]
 
Conjugate[Curve[Private`cr_IFun, Private`opts___]] ^:= 
    Curve[Conjugate[Private`cr], Private`opts]
 
Curve[Private`cr_IFun, Private`opts___] + (Private`c_)?NumberQ ^:= 
    Curve[Private`c + Private`cr, Private`opts]
 
Curve[Private`cr_IFun, Private`opts___]*(Private`c_)?NumberQ ^:= 
    Curve[Private`c*Private`cr, Private`opts]
 
Curve /: Curve::usage = "Turns an IFun into a domain"
 
FFT[Private`f:{__?ScalarQ}] := Module[{Private`c, Private`cc, Private`n, 
      Private`scale, Private`k}, Private`n = Length[Private`f]; 
      Private`scale = Sqrt[1.*Private`n]; Private`cc = 
       -((Reverse[AlternatingVector[Private`n]]*Fourier[Private`f])/
         Private`scale); Private`c[0] = (-1)^Private`n*Private`cc[[1]]; 
      Private`c[Private`k_] /; Private`k < 0 := (-1)^Private`n*
        Private`cc[[1 - Private`k]]; Private`c[Private`k_] /; 
        Private`k > 0 := Private`cc[[-Private`k]]; If[EvenQ[Private`n], 
       ShiftList[Table[Private`c[Private`k], {Private`k, -(Private`n/2), 
          -1}], Table[Private`c[Private`k], {Private`k, 0, 
          Private`n/2 - 1}]], ShiftList[Table[Private`c[Private`k], 
         {Private`k, -((Private`n - 1)/2), -1}], Table[Private`c[Private`k], 
         {Private`k, 0, (Private`n - 1)/2}]]]]
 
FFT[Private`f:{__?ArrayQ}] := ToShiftListOfArrays[
     Map[FFT, ToArrayOfLists[Private`f], {-2}]]
 
FFT[Private`if_LFun] := FFT[Values[Private`if]]
 
FFT /: FFT::usage = 
     "Returns a ShiftList of Laurent coefficients of a LFun or its value \
list."
 
ScalarQ[Private`f_] := NumberQ[N[Private`f]]
 
ScalarQ /: ScalarQ::usage = "Tests whether something has a scalar value."
 
Private`cc[Private`z_] := Conjugate[Private`z]
 
AlternatingVector[Private`n_] := Table[(-1)^(Private`k + 1), 
     {Private`k, Private`n}]
 
AlternatingVector /: AlternatingVector::usage = "Alternating vector."
 
ToShiftListOfArrays[Private`ar_] := ShiftList[ToListOfArrays[
      ArrayMap[ToList, Private`ar]], Index[Flatten[Private`ar][[1]]]]
 
ToListOfArrays[(Private`A_)?MatrixQ] := Transpose[Private`A]
 
ToListOfArrays[(Private`A_)?(Length[Dimensions[#1]] == 3 & )] := 
    ToListOfMatrices[Private`A]
 
ToListOfArrays[(Private`A_)?VectorQ] := Private`A
 
ToListOfMatrices[Private`gg_] := Array[Private`gg[[All,All,#1]] & , 
     Length[First[First[Private`gg]]]]
 
ArrayMap[Private`f_, (Private`m_)?MatrixQ] := MatrixMap[Private`f, Private`m]
 
ArrayMap[Private`f_, (Private`m_)?VectorQ] := Private`f /@ Private`m
 
ArrayMap[Private`f_, (Private`m_)?TensorQ] := 
    (MatrixMap[Private`f, #1] & ) /@ Private`m
 
ArrayMap[Private`f_, Private`m_ShiftList] := ArrayMap[Private`f, 
     ToArrayOfShiftLists[Private`m]]
 
ArrayMap[Private`f_, (Private`g_)?ScalarFunQ] := Private`f[Private`g]
 
ArrayMap[Private`f_, (Private`g_)?FunQ] := ArrayMap[Private`f, 
     ToArrayOfFuns[Private`g]]
 
ArrayMap[Private`f_, Private`m_] := Private`f[Private`m]
 
MatrixMap[Private`f_, (Private`g_)?FunQ] := MatrixMap[Private`f, 
     ToMatrixOfFuns[Private`g]]
 
MatrixMap[Private`f_, Private`m_] := Map[Private`f, Private`m, {2}]
 
ToMatrixOfFuns[Private`f_] := MatrixMap[
     Head[Private`f][#1, Domain[Private`f]] & , ToMatrixOfLists[
      Values[Private`f]]]
 
ToMatrixOfFuns /: ToMatrixOfFuns::usage = 
     "Changes an IFun whose values are a matrix to a matrix of IFuns"
 
ToMatrixOfLists[Private`g1_] := Array[Private`g1[[All,#1,#2]] & , 
     Dimensions[First[Private`g1]]]
 
ToArrayOfShiftLists[Private`sl_] := Map[ShiftList[#1, Index[Private`sl]] & , 
     ToArrayOfLists[ToList[Private`sl]], {-2}]
 
ToArrayOfLists[(Private`A_)?MatrixQ] := Transpose[Private`A]
 
ToArrayOfLists[(Private`A_)?(Length[Dimensions[#1]] == 3 & )] := 
    ToMatrixOfLists[Private`A]
 
ToArrayOfLists[(Private`A_)?VectorQ] := Private`A
 
ScalarFunQ[(Private`f_)?FunQ] := ScalarQ[First[Values[Private`f]]]
 
ScalarFunQ[_] := False
 
ToArrayOfFuns[(Private`f_)?MatrixFunQ] := ToMatrixOfFuns[Private`f]
 
ToArrayOfFuns[(Private`f_)?VectorFunQ] := 
    (Head[Private`f][#1, Domain[Private`f]] & ) /@ 
     ToArrayOfLists[Values[Private`f]]
 
ToArrayOfFuns[(Private`f_)?ScalarFunQ] := Private`f
 
MatrixFunQ[(Private`f_)?FunQ] := MatrixQ[First[Values[Private`f]]]
 
MatrixFunQ[_] := False
 
MatrixFunQ /: MatrixFunQ::usage = 
     "Tests if an object is in IFun whose values are a matrix."
 
VectorFunQ[(Private`f_)?FunQ] := VectorQ[First[Values[Private`f]]]
 
VectorFunQ[_] := False
 
VectorFunQ /: VectorFunQ::usage = 
     "Tests if an object is in IFun whose values are a vector."
 
Attributes[Private`f$] = {Temporary}
 
Attributes[Private`g$] = {Temporary}
 
FastPlus[Private`f$__IFun] := IFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__LFun] := LFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__PFun] := PFun[Plus @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
FastPlus[Private`f$__SingFun] := SingFun[Head[First[First[{Private`f$}]]][
      Plus @@ Values /@ {Private`f$}, Domain[First[First[{Private`f$}]]]], 
     Second[First[{Private`f$}]]]
 
PFun[Private`c0_, Private`d_][Private`z_] := Private`c0[[1]]
 
Values[PFun[Private`c0_, _]] ^:= Private`c0
 
(Private`f$_) /@ (Private`g$_PFun) ^:= PFun[Private`f$ /@ Values[Private`g$], 
     Domain[Private`g$]]
 
Length[Private`if_PFun] ^:= Length[Values[Private`if]]
 
(Private`f_PFun) + (Private`g_PFun) ^:= FastPlus[Private`f, Private`g]
 
(Private`f_PFun)*(Private`g_PFun) ^:= Private`FastTimes[Private`f, Private`g]
 
(Private`g$_PFun) + (Private`f$_)?ConstantQ ^:= 
    PFun[Values[Private`g$] + Private`f$, Domain[Private`g$]]
 
(Private`g$_PFun)*(Private`f$_)?ConstantQ ^:= 
    PFun[Values[Private`g$]*Private`f$, Domain[Private`g$]]
 
(Private`f$_PFun)^(Private`c$_)?ConstantQ ^:= 
    PFun[Values[Private`f$]^Private`c$, Domain[Private`f$]]
 
(Private`c$_)?ConstantQ^(Private`f$_PFun) ^:= 
    PFun[Private`c$^Values[Private`f$], Domain[Private`f$]]
 
(Private`f_PFun)?ArrayFunQ . (Private`g_PFun)?ArrayFunQ ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f] . ToArrayOfFuns[Private`g]]
 
PFun /: (Private`f_List)?( !ArrayFunQ[#1] & ) . (Private`g_PFun)?ArrayFunQ := 
     ToArrayFun[Private`f . ToArrayOfFuns[Private`g]]
 
Abs[Private`if$_PFun] ^:= PFun[Abs[Values[Private`if$]], Domain[Private`if$]]
 
Arg[Private`if$_PFun] ^:= PFun[Arg[Values[Private`if$]], Domain[Private`if$]]
 
Re[Private`if$_PFun] ^:= PFun[Re[Values[Private`if$]], Domain[Private`if$]]
 
Im[Private`if$_PFun] ^:= PFun[Im[Values[Private`if$]], Domain[Private`if$]]
 
Conjugate[Private`if$_PFun] ^:= PFun[Conjugate[Values[Private`if$]], 
     Domain[Private`if$]]
 
Exp[Private`if$_PFun] ^:= PFun[Exp[Values[Private`if$]], Domain[Private`if$]]
 
Tan[Private`if$_PFun] ^:= PFun[Tan[Values[Private`if$]], Domain[Private`if$]]
 
ArcSin[Private`if$_PFun] ^:= PFun[ArcSin[Values[Private`if$]], 
     Domain[Private`if$]]
 
Sec[Private`if$_PFun] ^:= PFun[Sec[Values[Private`if$]], Domain[Private`if$]]
 
Sin[Private`if$_PFun] ^:= PFun[Sin[Values[Private`if$]], Domain[Private`if$]]
 
Cos[Private`if$_PFun] ^:= PFun[Cos[Values[Private`if$]], Domain[Private`if$]]
 
Log[Private`if$_PFun] ^:= PFun[Log[Values[Private`if$]], Domain[Private`if$]]
 
ArcTanh[Private`if$_PFun] ^:= PFun[ArcTanh[Values[Private`if$]], 
     Domain[Private`if$]]
 
NIntegrate[Private`f_PFun] ^:= DomainIntegrate[Private`f]
 
Inverse[Private`if_PFun] ^:= Inverse /@ Private`if
 
Transpose[Private`f_PFun] ^:= Transpose /@ Private`f
 
Max[Private`f_PFun] ^:= Max[Values[Private`f]]
 
Min[Private`f_PFun] ^:= Min[Values[Private`f]]
 
Norm[Private`f_PFun] ^:= Norm[Flatten[Values[Private`f]]]
 
First[Private`f_PFun] ^:= First[Values[Private`f]]
 
Last[Private`f_PFun] ^:= Last[Values[Private`f]]
 
Dimensions[Private`f_PFun] ^:= Dimensions[First[Private`f]]
 
(Private`f_PFun)?MatrixFunQ[[Private`i_,Private`j_]] ^:= 
    ToArrayFun[ToMatrixOfFuns[Private`f][[Private`i,Private`j]]]
 
(Private`f_PFun)?ListFunQ[[Private`i_]] ^:= 
    ToArrayFun[ToArrayOfFuns[Private`f][[Private`i]]]
 
Mean[Private`f_PFun] ^:= First[Values[Private`f]]
 
DiagonalMatrix[Private`f_PFun] ^:= DiagonalMatrix[Values[Private`f]]
 
IdentityMatrix[Private`f_PFun] ^:= IdentityMatrix[Length[Private`f]]
 
PFun[(Private`c0_)?ScalarQ, Private`d_] := PFun[{Private`c0}, Private`d]
 
PFun[Private`c0:{_, _, ___}, Private`d_] := PFun[{Private`c0}, Private`d]
 
PFun[(Private`f_)?(NotListOrPatternQ[#1] &&  !ScalarQ[#1] && 
          !ScalarQ[First[Flatten[#1]]] & ) & , Private`d_, 1] := 
    PFun[{Private`f[Private`d[[1]]]}, Private`d]
 
PFun[(Private`f_)?(NotListOrPatternQ[#1] &&  !ScalarQ[#1] && 
          !ScalarQ[First[Flatten[#1]]] & ) & , Private`d_, 
     Private`opts:OptionsPattern[]] := PFun[Private`f, Private`d, 1]
 
PFun /: PFun::usage = 
     "PFun[c0,p0,n] defines a function taking the value c0 and the point p0."
 
Private`FastTimes[Private`f$__IFun] := IFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
Private`FastTimes[Private`f$__LFun] := LFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
Private`FastTimes[Private`f$__PFun] := PFun[Times @@ Values /@ {Private`f$}, 
     Domain[{Private`f$}[[1]]]]
 
ConstantQ[Private`f_] := NumberQ[N[Private`f]]
 
Attributes[Private`c$] = {Temporary}
 
ArrayFunQ[(Private`f_)?FunQ] := ArrayQ[First[Values[Private`f]]]
 
ArrayFunQ[_] := False
 
ArrayFunQ /: ArrayFunQ::usage = 
     "Tests if an object is in IFun whose values are an array."
 
ToArrayFun[Private`f_] := Head[Flatten[{Private`f}][[1]]][
     ToListOfArrays[ArrayMap[Values, Private`f]], 
     Domain[First[Flatten[{Private`f}]]]]
 
Attributes[Private`if$] = {Temporary}
 
DomainIntegrate[Private`if_IFun] := Last[Integrate[Private`if]]
 
DomainIntegrate[(Private`if_LFun)?(Domain[#1][[1]] == 
        {-Infinity, Infinity} & )] := 
    FFT[Values[Private`if]*Values[LFun[If[#1 == -1., 0, MapFromCircleD[
             Private`if, #1]] & , UnitCircle, Length[Private`if]]]][[-1]]*
     (2*Pi*I)
 
DomainIntegrate[Private`if_LFun] := 
    FFT[Values[Private`if]*Values[LFun[MapFromCircleD[Private`if, #1] & , 
          UnitCircle, Length[Private`if]]]][[-1]]*(2*Pi*I)
 
DomainIntegrate[{(Private`if__)?FunQ}] := 
    Plus @@ DomainIntegrate /@ {Private`if}
 
DomainIntegrate[SingFun[Private`if_IFun, {-1/2, -1/2}]] := 
    MapFromIntervalD[Domain[Private`if], 0]*Pi*Mean[Private`if]
 
DomainIntegrate[SingFun[Private`if_IFun, {1/2, 1/2}]] := 
    First[ToChebyshevUSeries[DCT[(MapFromIntervalD[Domain[Private`if], 0]*Pi*
         Private`if)/2]]]
 
DomainIntegrate /: DomainIntegrate::usage = "DomainIntegrate[ifun] returns \
the definite integral of the function ifun over its domain."
 
MapFromCircleD[Circle[Private`a_, Private`r_], Private`z_] := Private`r
 
MapFromCircleD[Circle[Private`a_, Private`r_, Orientation -> 1], 
     Private`z_] := Private`r
 
MapFromCircleD[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := -(Private`r/Private`z^2)
 
MapFromCircleD[Line[{-Infinity, Infinity}], Private`z_] := 
    -((2*I)/(1 + Private`z)^2)
 
MapFromCircleD[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`z_] := -((2*I)/(Private`L*(1 + Private`z)^2))
 
MapFromCircleD[Line[{-Pi, Pi}], Private`z_] := 
    Derivative[1][CircleToPeriodicInterval][Private`z]
 
MapFromCircleD[Private`l_Line, Private`z_] := 
    (MapFromIntervalD[Private`l, MapFromCircle[Private`PeriodicInterval, 
         Private`z]/Pi]*MapFromCircleD[Private`PeriodicInterval, Private`z])/
     Pi
 
MapFromCircleD[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapFromIntervalD[Line[{Private`a, Private`b}], CircleToInterval[
       MapFromCircle[Circle[0, Private`r], Private`z]]]*
     Derivative[1][CircleToInterval][MapFromCircle[Circle[0, Private`r], 
       Private`z]]*MapFromCircleD[Circle[0, Private`r], Private`z]
 
MapFromCircleD[Private`f_LFun, Private`z_] := 
    MapFromCircleD[Domain[Private`f], Private`z]
 
MapFromCircleD[Curve[Private`cr_LFun], Private`z_] := 
    MapDot[Private`z^#1 & , FFT[Derivative[1][Private`cr]]]
 
MapFromCircleD /: MapFromCircleD::usage = 
     "MapFromCircleD[d,z] is the derivative of MapFromCircle[d,z]."
 
Attributes[Derivative] = {NHoldAll, ReadProtected}
 
CircleToPeriodicInterval[Private`z_] := -(I*Log[Private`z])
 
Attributes[MapFromIntervalD] = {Listable}
 
MapFromIntervalD[Line[{_?InfinityQ, _?InfinityQ}], Private`x_] := 
    Derivative[1][IntervalToRealLine][Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], 1.] := 0.
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`x_] := 
    (2*E^(I*Arg[Private`b])*Private`L)/(-1 + Private`x)^2
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`x_] := 
    -MapFromIntervalD[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      -Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 1.] := 
    0.
 
MapFromIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`x_] := MapFromIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     -1.] := 0.
 
MapFromIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`x_] := MapFromIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromIntervalD[Line[{Private`a_, Private`b_}], Private`x_] := 
    (Private`b - Private`a)/2
 
MapFromIntervalD[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (2*(-(Private`a*Private`L) + Private`b*Private`L))/
     (1 + Private`L - Private`z + Private`L*Private`z)^2
 
MapFromIntervalD[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`x_] := (2*E^((1*I*(Private`t0 + Private`t1))/2)*
      (-E^(I*Private`t0) + E^(I*Private`t1))*Private`r)/
     (E^((I*Private`t1)/2)*(-1 + Private`x) - E^((I*Private`t0)/2)*
        (1 + Private`x))^2
 
MapFromIntervalD[Private`f_IFun, Private`z_] := 
    MapFromIntervalD[Domain[Private`f], Private`z]
 
MapFromIntervalD[Curve[Private`cr_IFun], Private`z_] := 
    MapDot[ChebyshevT[#1 - 1, Private`z] & , DCT[Derivative[1][Private`cr]]]
 
MapFromIntervalD[Curve[Private`cr_IFun, Stretch -> Private`L_], 
     Private`z_] := MapFromIntervalD[Line[{-1, 1}, Stretch -> Private`L], 
      Private`z]*MapFromIntervalD[Curve[Private`cr], 
      MapFromInterval[Line[{-1, 1}, Stretch -> Private`L], Private`z]]
 
MapFromIntervalD /: MapFromIntervalD::usage = 
     "MapFromIntervalD[d,x] is the derivative of MapFromInterval[d,x]."
 
Attributes[IntervalToRealLine] = {Listable}
 
IntervalToRealLine[_?(NEqual[#1, 1.] & )] := Infinity
 
IntervalToRealLine[_?(NEqual[#1, -1.] & )] := -Infinity
 
IntervalToRealLine[(Private`x_)?NumberQ] := Private`x/Sqrt[1 - Private`x^2]
 
Conjugate[Arc[Private`x0_, Private`r_, {Private`t0_, Private`t1_}]] ^:= 
    Arc[Conjugate[Private`x0], Private`r, {-Private`t0, -Private`t1}]
 
Arc[Private`x0_, Private`r_, {Private`t0_, Private`t1_}]*
     (Private`c_)?NumberQ ^:= Arc[Private`c*Private`x0, Private`r, 
     {Pi - Private`t0, Pi - Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Left] /; 
     Private`t0 < Private`t1 := Arc[Private`a, Private`r, 
     {Private`t0, Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Left] := 
    Arc[Private`a, Private`r, {Private`t0 - 2*Pi, Private`t1}, Left]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Right] /; 
     Private`t0 > Private`t1 := Arc[Private`a, Private`r, 
     {Private`t0, Private`t1}]
 
Arc[Private`a_, Private`r_, {Private`t0_, Private`t1_}, Right] := 
    Arc[Private`a, Private`r, {Private`t0 + 2*Pi, Private`t1}, Right]
 
Arc[{Private`a_, Private`b_, Private`c_}] := 
    Function[Private`x0, Arc[Private`x0, Abs[Private`a - Private`x0], 
       {Arg[Private`a - Private`x0], Arg[Private`c - Private`x0]}]][
     (Det[{{Abs[Private`a]^2, Im[Private`a], 1}, {Abs[Private`b]^2, 
          Im[Private`b], 1}, {Abs[Private`c]^2, Im[Private`c], 1}}] - 
       I*Det[{{Abs[Private`a]^2, Re[Private`a], 1}, {Abs[Private`b]^2, 
           Re[Private`b], 1}, {Abs[Private`c]^2, Re[Private`c], 1}}])/
      (2*Det[{{Re[Private`a], Im[Private`a], 1}, {Re[Private`b], 
          Im[Private`b], 1}, {Re[Private`c], Im[Private`c], 1}}])]
 
Arc /: Arc::usage = "Arc[z0,r,{t0,t1}] represents the arc centred at z0 of \
radius r from argument t0 to t1."
 
DCT[Private`f:{__?ScalarQ}] := AlternatingVector[Length[Private`f]]*
     HalfFirstAndLast[FourierDCT[Private`f, 1]*
       Sqrt[2/(Length[Private`f] - 1)]]
 
DCT[Private`f:{__?VectorQ}] := ToListOfArrays[
     DCT /@ ToArrayOfLists[Private`f]]
 
DCT[Private`f:{__?MatrixQ}] := ToListOfArrays[MatrixMap[DCT, 
      ToArrayOfLists[Private`f]]]
 
DCT[(Private`f_IFun)?ArrayFunQ] := ToListOfArrays[ArrayMap[DCT, Private`f]]
 
DCT[Private`if_IFun] := DCT[Values[Private`if]]
 
DCT[Private`sf_SingFun] := DCT[First[Private`sf]]
 
DCT /: DCT::usage = "DCT[ifun] returns the Chebyshev coefficients of an IFun."
 
HalfFirstAndLast[{Private`m1_, Private`m___, Private`m2_}] := 
    {Private`m1/2, Private`m, Private`m2/2}
 
SingFun[Private`if_IFun, {Private`\[Alpha]_, Private`\[Beta]_}][
     Private`x_] := Private`if[Private`x]*
     (MapToInterval[Private`if, Private`x] + 1)^Private`\[Alpha]*
     (1 - MapToInterval[Private`if, Private`x])^Private`\[Beta]
 
Values[Private`if_SingFun] ^:= Values[First[Private`if]]
 
(Private`f$_) /@ (Private`g$_SingFun) ^:= 
    SingFun[Private`f$ /@ Values[Private`g$], Domain[Private`g$]]
 
Length[Private`if_SingFun] ^:= Length[Values[Private`if]]
 
(Private`f:SingFun[_, {Private`a_, Private`b_}]) + 
     (Private`g:SingFun[_, {Private`a_, Private`b_}]) ^:= 
    FastPlus[Private`f, Private`g]
 
(Private`f_SingFun)*(Private`g_SingFun) ^:= FastTimes[Private`f, Private`g]
 
(Private`g$_SingFun)*(Private`f$_)?ConstantQ ^:= 
    SingFun[First[Private`g$]*Private`f$, Second[Private`g$]]
 
(Private`f$_SingFun)^(Private`c$_)?ConstantQ ^:= 
    SingFun[First[Private`f$]^Private`c$, Second[Private`f$]*Private`c$]
 
Abs[Private`if$_SingFun] ^:= SingFun[Abs[First[Private`if$]], 
     Second[Private`if$]]
 
Arg[Private`if$_SingFun] ^:= SingFun[Arg[First[Private`if$]], 
     Second[Private`if$]]
 
Re[Private`if$_SingFun] ^:= SingFun[Re[First[Private`if$]], 
     Second[Private`if$]]
 
Im[Private`if$_SingFun] ^:= SingFun[Im[First[Private`if$]], 
     Second[Private`if$]]
 
Conjugate[Private`if$_SingFun] ^:= SingFun[Conjugate[First[Private`if$]], 
     Second[Private`if$]]
 
Dimensions[Private`f_SingFun] ^:= Dimensions[First[Private`f]]
 
NIntegrate[Private`sf_SingFun] ^:= DomainIntegrate[Private`sf]
 
Integrate[SingFun[Private`f_IFun, {0, 0}]] ^:= SingFun[Integrate[Private`f], 
     {0, 0}]
 
SingFun[Private`f_, (Private`d_)?DomainQ, {Private`\[Alpha]_, 
      Private`\[Beta]_}] := 
    SingFun[((RightEndpoint[Private`d] - LeftEndpoint[Private`d])^
        (Private`\[Beta] + Private`\[Alpha])*IFun[Private`f, Private`d])/
      2^(Private`\[Alpha] + Private`\[Beta]), {Private`\[Alpha], 
      Private`\[Beta]}]
 
SingFun[Private`f_, (Private`d_)?DomainQ, {Private`\[Alpha]_, 
      Private`\[Beta]_}, Private`n_Integer] := 
    SingFun[((RightEndpoint[Private`d] - LeftEndpoint[Private`d])^
        (Private`\[Beta] + Private`\[Alpha])*IFun[Private`f, Private`d, 
        Private`n])/2^(Private`\[Alpha] + Private`\[Beta]), 
     {Private`\[Alpha], Private`\[Beta]}]
 
MakeBoxes[Private`sf:SingFun[_IFun, {_, _}], FormatType_] ^:= 
    Format[ReImLinePlot[Private`sf, Sequence @@ $FunFormat], FormatType]
 
Format[Private`sf:SingFun[_IFun, {_, _}]] := ReImLinePlot[Private`sf, 
     Sequence @@ $FunFormat]
 
FastTimes[Private`f$__SingFun] := SingFun[Head[First[First[{Private`f$}]]][
      Times @@ Values /@ {Private`f$}, Domain[First[First[{Private`f$}]]]], 
     Total[Second /@ {Private`f$}]]
 
Second := #1[[2]] & 
 
DomainQ[(Private`d_)?IntervalDomainQ] := True
 
DomainQ[(Private`d_)?CircleDomainQ] := True
 
DomainQ[_?PointDomainQ] := True
 
DomainQ[_] := False
 
DomainQ /: DomainQ::usage = 
     "Test whether something is a domain (Line, Arc, Circle, Curve, etc)."
 
IntervalDomainQ[Line[{-Infinity, Infinity}]] := False
 
IntervalDomainQ[_Line] := True
 
IntervalDomainQ[_Arc] := True
 
IntervalDomainQ[Curve[_IFun]] := True
 
IntervalDomainQ[_Ellipse] := False
 
IntervalDomainQ[_] := False
 
IntervalDomainQ /: IntervalDomainQ::usage = 
     "Test whether something is a domain mapped from the unit interval."
 
CircleDomainQ[Line[{-Infinity, Infinity}]] := True
 
CircleDomainQ[_Circle] := True
 
CircleDomainQ[_Ellipse] := True
 
CircleDomainQ[Curve[_LFun]] := True
 
CircleDomainQ[_] := False
 
CircleDomainQ /: CircleDomainQ::usage = 
     "Test whether something is a domain mapped from the unit circle."
 
PointDomainQ[_Point] := True
 
PointDomainQ[_] := False
 
RightEndpoint[Line[{Private`a_, Private`b_}, ___]] := Private`b
 
RightEndpoint[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}]] := 
    N[Private`z0 + Private`r*Exp[I*Private`t1]]
 
RightEndpoint[Private`f_IFun] := RightEndpoint[Domain[Private`f]]
 
RightEndpoint[Private`if_SingFun] := RightEndpoint[First[Private`if]]
 
RightEndpoint[Private`comp_] := MapFromInterval[Private`comp, 1]
 
RightEndpoint /: RightEndpoint::usage = "RightEndpoint[d] returns the right \
endpoint of the domain d. If d is an IFun, then it is equivalent to \
RightEndpoint[Domain[d]]."
 
Attributes[MapFromInterval] = {Listable}
 
MapFromInterval[Line[{_?InfinityQ, _?InfinityQ}], Private`x_] := 
    IntervalToRealLine[Private`x]
 
MapFromInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`x_] := 
    Private`L*Exp[I*Arg[Private`b]]*IntervalToHalfLine[Private`x] + Private`a
 
MapFromInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`x_] := MapFromInterval[
     Line[{Private`b, Private`a}, Stretch -> Private`L], -Private`x]
 
MapFromInterval[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`x_] := MapFromInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromInterval[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`x_] := MapFromInterval[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`x]
 
MapFromInterval[Line[{Private`a_, Private`b_}], Private`x_] := 
    (Private`b + Private`a)/2 + ((Private`b - Private`a)*Private`x)/2
 
MapFromInterval[Private`z_] := Private`z
 
MapFromInterval[Line[{Private`a_, Private`b_}, 
      Stretch -> _?(NEqual[1., #1] & )], _?InfinityQ] := Infinity
 
MapFromInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     _?InfinityQ] := (-Private`a + Private`b*Private`L)/(-1 + Private`L)
 
MapFromInterval[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := (Private`b*Private`L*(-1 - Private`z) + 
      Private`a*(-1 + Private`z))/(-1 - Private`L + Private`z - 
      Private`L*Private`z)
 
MapFromInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     _?InfinityQ] := -(E^((1*I*(Private`t0 + Private`t1))/2)*Private`r) + 
     Private`z0
 
MapFromInterval[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`x_] := (-(E^((1*I*(Private`t0 + 2*Private`t1))/2)*Private`r*
        (1 + Private`x)) - E^((I*Private`t0)/2)*(1 + Private`x)*Private`z0 + 
      E^((I*Private`t1)/2)*(-1 + Private`x)*(E^(I*Private`t0)*Private`r + 
        Private`z0))/(E^((I*Private`t1)/2)*(-1 + Private`x) - 
      E^((I*Private`t0)/2)*(1 + Private`x))
 
MapFromInterval[Private`f_IFun, Private`z_] := 
    MapFromInterval[Domain[Private`f], Private`z]
 
MapFromInterval[Curve[Private`cr_IFun], Private`z_] := 
    MapDot[ChebyshevT[#1 - 1, Private`z] & , DCT[Private`cr]]
 
MapFromInterval[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapFromInterval[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapFromInterval[Curve[Private`cr], MapFromInterval[
      Line[{-1, 1}, Stretch -> Private`L], Private`z]]
 
MapFromInterval /: MapFromInterval::usage = "MapFromInterval[d,x] maps the \
point x via the conformal map that maps the unit interval to the domain d. If \
d is an IFun, then it is equivalent to MapFromInterval[Domain[d],x]."
 
Attributes[IntervalToHalfLine] = {Listable}
 
IntervalToHalfLine[_?(NEqual[#1, 1.] & )] := Infinity
 
IntervalToHalfLine[_?InfinityQ] := -1.
 
IntervalToHalfLine[Private`x_] := (Private`x + 1)/(1 - Private`x)
 
LeftEndpoint[Line[{Private`a_, Private`b_}, ___]] := Private`a
 
LeftEndpoint[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}]] := 
    N[Private`z0 + Private`r*Exp[I*Private`t0]]
 
LeftEndpoint[Private`f_IFun] := LeftEndpoint[Domain[Private`f]]
 
LeftEndpoint[Private`if_SingFun] := LeftEndpoint[First[Private`if]]
 
LeftEndpoint[Private`comp_] := MapFromInterval[Private`comp, -1]
 
LeftEndpoint /: LeftEndpoint::usage = "LeftEndpoint[d] returns the left \
endpoint of the domain d. If d is an IFun, then it is equivalent to \
LeftEndpoint[Domain[d]]."
 
ReImLinePlot[(Private`f_)?VectorFunQ, Private`opts___] := 
    MatrixForm[{ArrayMap[ReImLinePlot[#1, Private`opts] & , 
       ToArrayOfFuns[Private`f]]}]
 
ReImLinePlot[(Private`f_)?ArrayFunQ, Private`opts___] := 
    MatrixForm[ArrayMap[ReImLinePlot[#1, Private`opts] & , 
      ToArrayOfFuns[Private`f]]]
 
ReImLinePlot[Private`f_, Private`opts___] := 
    ListLinePlot[{Private`PlotPointValueList[Re[Private`f]], 
      Private`PlotPointValueList[Im[Private`f]]}, Private`opts]
 
Private`PlotPointValueList[(Private`f_)?FunQ] := 
    Thread[{Private`FiniteRealPoints[Private`f], FiniteValues[Private`f]}]
 
Private`PlotPointValueList[SingFun[Private`f_IFun, {Private`\[Alpha]_, 
       Private`\[Beta]_}]] := Private`PlotPointValueList[
     Fun[Piecewise[{{0, (NEqual[#1, RightEndpoint[Private`f]] && 
             Private`\[Beta] != 0) || (NEqual[#1, LeftEndpoint[Private`f]] && 
             Private`\[Alpha] != 0)}, 
          {1, (NEqual[#1, RightEndpoint[Private`f]] && Private`\[Beta] == 
              0) || (NEqual[#1, LeftEndpoint[Private`f]] && 
             Private`\[Alpha] == 0)}, {(MapToInterval[Private`f, #1] + 1)^
             Private`\[Alpha]*(1 - MapToInterval[Private`f, #1])^
             Private`\[Beta], True}}] & , Domain[Private`f], 100]*
      SetLength[Private`f, 100]]
 
Private`FiniteRealPoints[Private`if:IFun[_, Line[{-Infinity, Infinity}]]] := 
    FinitePoints[Private`if]
 
Private`FiniteRealPoints[Private`if_IFun] /; 
     NEqual[Re[LeftEndpoint[Private`if]], Re[RightEndpoint[Private`if]]] := 
    Im[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[Private`if_LFun] := Re[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[Private`if_PFun] := Re[FinitePoints[Private`if]]
 
Private`FiniteRealPoints[(Private`if_)?FunQ] := Re[FinitePoints[Private`if]]
 
FinitePoints[(Private`if_IFun)?(LeftEndpointInfinityQ[#1] && 
        RightEndpointInfinityQ[#1] & )] := 
    Rest[Most[IntervalPoints[Private`if]]]
 
FinitePoints[(Private`if_IFun)?LeftEndpointInfinityQ] := 
    Rest[IntervalPoints[Private`if]]
 
FinitePoints[(Private`if_IFun)?RightEndpointInfinityQ] := 
    Most[IntervalPoints[Private`if]]
 
FinitePoints[Private`if_IFun] := IntervalPoints[Private`if]
 
FinitePoints[Private`if:LFun[_, Line[{-Infinity, Infinity}, ___]]] := 
    Rest[Points[Private`if]]
 
FinitePoints[Private`if_LFun] := Points[Private`if]
 
FinitePoints[Private`if_PFun] := Points[Private`if]
 
FinitePoints[Private`l:{__?FunQ}] := Flatten[FinitePoints /@ Private`l]
 
FinitePoints[Private`d_, Private`n_] := Points[Private`d, Private`n]
 
LeftEndpointInfinityQ[Line[{_?InfinityQ, _}, ___]] := True
 
LeftEndpointInfinityQ[Private`f_IFun] := LeftEndpointInfinityQ[
     Domain[Private`f]]
 
LeftEndpointInfinityQ[_] := False
 
LeftEndpointInfinityQ /: LeftEndpointInfinityQ::usage = 
     "LeftEndpointInfinityQ[d] tests if a domain's left endpoint is \
unbounded."
 
RightEndpointInfinityQ[Line[{_, _?InfinityQ}, ___]] := True
 
RightEndpointInfinityQ[Private`f_IFun] := RightEndpointInfinityQ[
     Domain[Private`f]]
 
RightEndpointInfinityQ[_] := False
 
RightEndpointInfinityQ /: RightEndpointInfinityQ::usage = 
     "RightEndpointInfinityQ[d] tests if a domain's right endpoint is \
unbounded."
 
IntervalPoints[Private`d_, Private`n_] := MapFromInterval[Private`d, 
     NChebyshevLobattoPoints[Private`n]]
 
IntervalPoints[Private`f_IFun] := Points[Private`f]
 
Points[(Private`d_)?IntervalDomainQ, Private`n_] := 
    IntervalPoints[Private`d, Private`n]
 
Points[Private`if_IFun] := IntervalPoints[Domain[Private`if], 
     Length[Private`if]]
 
Points[(Private`d_)?CircleDomainQ, Private`n_] := MapFromCircle[Private`d, 
     Private`ComplexCirclePoints[Private`n]]
 
Points[Private`lf_LFun] := MapFromCircle[Domain[Private`lf], 
     Points[UnitCircle, Length[Private`lf]]]
 
Points[Point[Private`z0_], 1] := {Private`z0}
 
Points[Private`if_PFun] := Points[Domain[Private`if], Length[Private`if]]
 
Points[Private`l:{__?FunQ}] := Flatten[Points /@ Private`l]
 
Points[Private`if_SingFun] := Points[Domain[Private`if], Length[Private`if]]
 
Points /: Points::usage = "Points[ifun] returns the the mapped \
Chebyshev\[Dash]Lobatto points.  Points[d,n] returns n mapped \
Chebyshev\[Dash]Lobatto points over a domain d."
 
Attributes[MapFromCircle] = {Listable}
 
MapFromCircle[Circle[Private`a_, Private`r_], Private`z_] := 
    Private`r*Private`z + Private`a
 
MapFromCircle[Circle[Private`a_, Private`r_, Orientation -> 1], 
     Private`z_] := Private`r*Private`z + Private`a
 
MapFromCircle[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := Private`r/Private`z + Private`a
 
MapFromCircle[Line[{-Infinity, Infinity}], _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}], Private`z_] := 
    (-(I*Private`z) + I)/(Private`z + 1)
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`z_] := -((I*(-1 + Private`z))/(Private`L*(1 + Private`z)))
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{-Infinity, Infinity}, Stretch -> Private`L_, 
      Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(-1 + Private`z))/(Private`L*(1 + Private`z))
 
MapFromCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{DirectedInfinity[-I], DirectedInfinity[I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(I*(-1 + Private`z)))/(Private`L*(1 + Private`z))
 
MapFromCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], 
     _?(NEqual[#1, -1.] & )] := Infinity
 
MapFromCircle[Line[{DirectedInfinity[I], DirectedInfinity[-I]}, 
      Stretch -> Private`L_, Centre -> Private`a_], Private`z_] := 
    Private`a - (I*(I*(-1 + 1/Private`z)))/(Private`L*(1 + 1/Private`z))
 
MapFromCircle[Line[{-Pi, Pi}], Private`z_] := CircleToPeriodicInterval[
     Private`z]
 
MapFromCircle[Private`l_Line, Private`z_] := MapFromInterval[Private`l, 
     MapFromCircle[Private`PeriodicInterval, Private`z]/Pi]
 
MapFromCircle[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapFromInterval[Line[{Private`a, Private`b}], 
     CircleToInterval[MapFromCircle[Circle[0, Private`r], Private`z]]]
 
MapFromCircle[Private`f_LFun, Private`z_] := MapFromCircle[Domain[Private`f], 
     Private`z]
 
MapFromCircle[Curve[Private`cr_LFun], Private`z_] := 
    MapDot[Private`z^#1 & , FFT[Private`cr]]
 
MapFromCircle[Curve[Private`cr_], (Private`z_)?InfinityQ] := Private`z
 
MapFromCircle[Curve[Private`cr_], (Private`z_)?ZeroQ] := 0
 
MapFromCircle /: MapFromCircle::usage = "MapToCircle[d,z] maps z via the \
conformal map from the unit circle to the domain d."
 
CircleToInterval[Private`z_] := (1*(Private`z + 1/Private`z))/2
 
CircleToInterval /: CircleToInterval::usage = 
     "CircleToInterval[z] conformally maps the unit circle to the unit \
interval."
 
ZeroQ[Private`f_] := Private`f == 0
 
Private`ComplexCirclePoints[Private`n_] := Exp[I*Pi*LeftEvenPoints[Private`n]]
 
LeftEvenPoints[Private`n_] := Range[-1, (Private`n - 1)/Private`n, 
     2/Private`n]
 
LeftEvenPoints[Private`n_, Private`a_, Private`b_] := 
    Private`a + ((Private`b - Private`a)*(1 + LeftEvenPoints[Private`n]))/2
 
LeftEvenPoints /: LeftEvenPoints::usage = 
     "Evenly spaced points on the unit interval."
 
UnitCircle = Circle[0, 1]
 
UnitCircle /: UnitCircle::usage = "The unit circle Circle[0.,1.]."
 
FiniteValues[(Private`if_IFun)?(LeftEndpointInfinityQ[#1] && 
        RightEndpointInfinityQ[#1] & )] := Rest[Most[Values[Private`if]]]
 
FiniteValues[(Private`if_IFun)?LeftEndpointInfinityQ] := 
    Rest[Values[Private`if]]
 
FiniteValues[(Private`if_IFun)?RightEndpointInfinityQ] := 
    Most[Values[Private`if]]
 
FiniteValues[Private`if_IFun] := Values[Private`if]
 
FiniteValues[Private`if_LFun] := 
    Last /@ Select[Thread[{Points[Private`if], Values[Private`if]}], 
       !InfinityQ[First[#1]] & ]
 
FiniteValues[Private`pf_PFun] := Values[Private`pf]
 
Fun[(Private`f_)?NotListOrPatternQ, Private`l:Line[{_, _}, ___], 
     Private`opts___] := IFun[Private`f, Private`l, Private`opts]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`n_List] := 
    (If[Length[#1] == 1, #1[[1]], #1] & )[
     (IFun[Private`f, Line[#1[[1]], Sequence @@ 
          If[Or @@ InfinityQ /@ #1[[1]], {Private`Lopts}, {}]], 
        #1[[2]]] & ) /@ Thread[{Partition[Private`l, 2, 1], Private`n}]]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`n_Integer] := 
    Fun[Private`f, Line[Private`l, Private`Lopts], 
     Private`n*OneVector[Length[Private`l] - 1]]
 
Fun[(Private`f_)?NotListOrPatternQ, Line[Private`l:{_, _, ___}, 
      Private`Lopts___], Private`opts:OptionsPattern[]] := 
    (If[Length[#1] == 1, #1[[1]], #1] & )[
     (IFun[Private`f, Line[#1, Sequence @@ If[Or @@ InfinityQ /@ #1, 
           {Private`Lopts}, {}]], Private`opts] & ) /@ 
      Partition[Private`l, 2, 1]]
 
Fun[Private`f_, (Private`d_)?IntervalDomainQ, Private`opts___] := 
    IFun[Private`f, Private`d, Private`opts]
 
Fun[Private`a_] := Fun[Private`a, UnitInterval]
 
Fun[Private`f_, (Private`d_)?CircleDomainQ, Private`opts___] := 
    LFun[Private`f, Private`d, Private`opts]
 
Fun[Private`f_, (Private`d_)?PointDomainQ, Private`opts___] := 
    PFun[Private`f, Private`d, Private`opts]
 
Fun[Private`f_, Private`l_List, Private`n_List] := 
    Flatten[(Fun[Private`f, #1[[1]], #1[[2]]] & ) /@ 
      Thread[{Private`l, Private`n}]]
 
Fun[Private`f_, Private`l_List, Private`opts___] := 
    Flatten[(Fun[Private`f, #1, Private`opts] & ) /@ Private`l]
 
Fun /: Fun::usage = 
     "\nDecides between IFun and LFun, and allows Line[{a,b,c}]"
 
NotListOrPatternQ[Private`f_] :=  !ListQ[Private`f] && 
      !Head[Private`f] === Pattern &&  !Head[Private`f] === Blank
 
OneVector[Private`n_] := Table[1, {Private`n}]
 
OneVector /: OneVector::usage = 
     "OneVector[n] constructs a vector of length n of all ones."
 
UnitInterval = Line[{-1, 1}]
 
UnitInterval /: UnitInterval::usage = "The unit interval Line[{-1.,1.}]."
 
SetLength[Private`if_IFun, Private`n_] := 
    IFun[InverseDCT[PadRight[DCT[Private`if], Private`n]], Domain[Private`if]]
 
SetLength[Private`if_LFun, (Private`n_)?OddQ] := 
    LFun[InverseFFT[SetIndexRange[FFT[Private`if], {(1 - Private`n)/2, 
        (Private`n - 1)/2}]], Domain[Private`if]]
 
SetLength[Private`if_LFun, (Private`n_)?EvenQ] := 
    LFun[InverseFFT[SetIndexRange[FFT[Private`if], {-(Private`n/2), 
        Private`n/2 - 1}]], Domain[Private`if]]
 
InverseDCT[Private`f:{__?ScalarQ}] := 
    Reverse[((Length[Private`f] - 1)*AlternatingVector[Length[Private`f]]*
       DoubleFirstAndLast[DCT[DoubleFirstAndLast[Private`f]]])/2]
 
InverseDCT[Private`f:{__?VectorQ}] := ToListOfArrays[
     InverseDCT /@ ToArrayOfLists[Private`f]]
 
InverseDCT[Private`f:{__?MatrixQ}] := ToListOfArrays[
     MatrixMap[InverseDCT, ToArrayOfLists[Private`f]]]
 
DoubleFirstAndLast[{Private`m1_, Private`m___, Private`m2_}] := 
    {Private`m1*2, Private`m, Private`m2*2}
 
InverseFFT[Private`c:ShiftList[{__?ScalarQ}, _]] := 
    Module[{Private`scale, Private`cc, Private`cf, Private`j, Private`n}, 
     Private`n = Length[Private`c]; Private`scale = 
       First[Fourier[(1 & ) /@ LeftEvenPoints[Private`n]]]; 
      InverseFourier[-(Reverse[AlternatingVector[Private`n]]*Private`scale*
         If[EvenQ[Private`n], RotateLeft[Reverse[ToList[Private`c]], 
           (Private`n - 2)/2], RotateLeft[Reverse[
            ToList[ShiftList[(-1)^Private`n*OneVector[(Private`n - 1)/2], 
               Join[{(-1)^Private`n}, OneVector[(Private`n - 1)/2]]]*
              Private`c]], (Private`n - 1)/2]])]]
 
InverseFFT[Private`sl:ShiftList[{__?ArrayQ}, _]] := 
    ToListOfArrays[ArrayMap[InverseFFT, ToArrayOfShiftLists[Private`sl]]]
 
InverseFFT /: InverseFFT::usage = "Returns values that a ShiftList of Laurent \
coefficients would take on the unit circle."
 
SetIndexRange[Private`sl_ShiftList, Private`ind_] := 
    Module[{Private`sl2}, Private`sl2 = PadLeft[Private`sl, 
        Length[Private`sl] + FirstIndex[Private`sl] - First[Private`ind]]; 
      PadRight[Private`sl2, Length[Private`sl2] + Last[Private`ind] - 
        LastIndex[Private`sl]]]
 
SetIndexRange[Private`sm_ShiftMatrix, {Private`i_, Private`j_}, 
     {Private`m_, Private`n_}] := PadRight[PadLeft[Private`sm, 
      {Private`i, Private`m}], {Private`j, Private`n}]
 
ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, Private`jind_}][[
     Private`i_,Private`j_]] ^:= Private`ls[[Private`fixind[Private`i, 
      Private`iind],Private`fixind[Private`j, Private`jind]]]
 
ShiftMatrix /: ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
        Private`jind_}][[Private`i_Integer]] := 
     ShiftList[Private`ls[[Private`fixind[Private`i, Private`iind]]], 
      Private`jind]
 
(Private`f_) /@ ShiftMatrix[(Private`ls_)?MatrixQ, 
      {Private`iind_, Private`jind_}] ^:= 
    (Private`f[ShiftList[#1, Private`jind]] & ) /@ Private`ls
 
Transpose[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] ^:= ShiftMatrix[Transpose[Private`ls], 
     {Private`jind, Private`iind}]
 
Inverse[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] ^:= ShiftMatrix[Inverse[Private`ls], 
     {Private`jind, Private`iind}]
 
Normal[Private`sl_ShiftMatrix] ^:= ToArray[Private`sl]
 
Dimensions[ShiftMatrix[(Private`ls_)?MatrixQ, {_, _}]] ^:= 
    Dimensions[Private`ls]
 
ShiftMatrix /: PadRight[Private`sm_ShiftMatrix, {Private`m_, Private`n_}] := 
     ShiftMatrix[PadRight[ToArray[Private`sm], 
       {Private`m + RowIndex[Private`sm], Private`n + 
         ColumnIndex[Private`sm]}], {RowIndex[Private`sm], 
       ColumnIndex[Private`sm]}]
 
ShiftMatrix /: PadLeft[Private`sm_ShiftMatrix, {Private`m_, Private`n_}] := 
     ShiftMatrix[PadLeft[ToArray[Private`sm], 
       {Length[ToArray[Private`sm]] - RowIndex[Private`sm] + 1 - Private`m, 
        Second[Dimensions[ToArray[Private`sm]]] - ColumnIndex[Private`sm] + 
         1 - Private`n}], {1 - Private`m, 1 - Private`n}]
 
ShiftMatrix /: (Private`sm_ShiftMatrix) . (Private`sl_ShiftList) := 
     ShiftList[ToArray[Private`sm] . ToList[Private`sl], 
      RangeIndex[Private`sm]]
 
ShiftMatrix /: (Private`sl_ShiftList) . (Private`sm_ShiftMatrix) := 
     ShiftList[ToList[Private`sl] . ToArray[Private`sm], 
      ColumnIndex[Private`sm]]
 
(Private`sm_ShiftMatrix) . (Private`sm2_ShiftMatrix) ^:= 
    ShiftMatrix[ToArray[Private`sm] . ToArray[Private`sm2], 
     {RangeIndex[Private`sm], DomainIndex[Private`sm2]}]
 
(Private`sm_ShiftMatrix) + (Private`sm2_ShiftMatrix) ^:= 
    ShiftMatrix[ToArray[Private`sm] + ToArray[Private`sm2], 
     {RangeIndex[Private`sm], DomainIndex[Private`sm2]}]
 
(Private`sm_ShiftMatrix)*(Private`c_)?NumberQ ^:= 
    ShiftMatrix[Private`c*ToArray[Private`sm], {RangeIndex[Private`sm], 
      DomainIndex[Private`sm]}]
 
ShiftMatrix /: LinearSolve[Private`sm_ShiftMatrix, Private`sl_ShiftList] := 
     ShiftList[LinearSolve[ToArray[Private`sm], ToList[Private`sl]], 
      DomainIndex[Private`sm]]
 
Re[ShiftMatrix[(Private`ls_)?MatrixQ, Private`ind_]] ^:= 
    ShiftMatrix[Re[Private`ls], Private`ind]
 
Im[ShiftMatrix[(Private`ls_)?MatrixQ, Private`ind_]] ^:= 
    ShiftMatrix[Im[Private`ls], Private`ind]
 
ShiftMatrix[{(Private`A_)?MatrixQ, (Private`B_)?MatrixQ}] := 
    ShiftMatrix[Private`RightJoin[Private`A, Private`B], 
     {1, Dimensions[Private`A][[2]] + 1}]
 
MakeBoxes[Private`sm:ShiftMatrix[_?MatrixQ, {_Integer, _Integer}], 
     FormatType_] ^:= Format[MatrixForm[Module[{Private`i, Private`j}, 
       Table[If[Private`i == 0 || Private`j == 0, 
         Style[Private`sm[[Private`i,Private`j]], Bold], 
         Private`sm[[Private`i,Private`j]]], {Private`i, 
         RowIndexRange[Private`sm][[1]], RowIndexRange[Private`sm][[2]]}, 
        {Private`j, ColumnIndexRange[Private`sm][[1]], 
         ColumnIndexRange[Private`sm][[2]]}]]], FormatType]
 
Format[Private`sm:ShiftMatrix[_?MatrixQ, {_Integer, _Integer}]] := 
    MatrixForm[Module[{Private`i, Private`j}, 
      Table[If[Private`i == 0 || Private`j == 0, 
        Style[Private`sm[[Private`i,Private`j]], Bold], 
        Private`sm[[Private`i,Private`j]]], {Private`i, 
        RowIndexRange[Private`sm][[1]], RowIndexRange[Private`sm][[2]]}, 
       {Private`j, ColumnIndexRange[Private`sm][[1]], 
        ColumnIndexRange[Private`sm][[2]]}]]]
 
ToArray[ShiftMatrix[Private`ls_, {_, _}]] := Private`ls
 
RowIndex[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] := Private`iind
 
ColumnIndex[ShiftMatrix[(Private`ls_)?MatrixQ, {Private`iind_, 
       Private`jind_}]] := Private`jind
 
RangeIndex := RowIndex
 
DomainIndex := ColumnIndex
 
RowIndexRange[Private`l_ShiftMatrix] := {1 - RowIndex[Private`l], 
     Dimensions[Private`l][[1]] - RowIndex[Private`l]}
 
ColumnIndexRange[Private`l_ShiftMatrix] := {1 - ColumnIndex[Private`l], 
     Dimensions[Private`l][[2]] - ColumnIndex[Private`l]}
 
$FunFormat = {ImageSize -> Small}
 
ToChebyshevUSeries[Private`ts:{_}] := Private`ts
 
ToChebyshevUSeries[Private`ts_] := DoubleFirst[Private`ts]/2 - 
     PadRight[Rest[Rest[Private`ts]]/2, Length[Private`ts]]
 
DoubleFirst[{Private`m1_, Private`m___}] := {2*Private`m1, Private`m}
 
ListFunQ[(Private`f_)?FunQ] := ListQ[First[Values[Private`f]]]
 
ListFunQ[_] := False
 
ListFunQ /: ListFunQ::usage = 
     "Tests if an object is in IFun whose values are a list."
 
MapToCircleD[Circle[Private`a_, Private`r_], Private`z_] := 1/Private`r
 
MapToCircleD[Circle[Private`a_, Private`r_, Orientation -> 1], Private`z_] := 
    1/Private`r
 
MapToCircleD[Circle[Private`a_, Private`r_, Orientation -> -1], 
     Private`z_] := -(Private`r/(Private`z - Private`a)^2)
 
MapToCircleD[Line[{-Infinity, Infinity}], Private`t_] := 
    -((2*I)/(I + Private`t)^2)
 
MapToCircleD[Line[{-Infinity, Infinity}, Stretch -> Private`L_], 
     Private`t_] := -((2*I*Private`L)/(I + Private`L*Private`t)^2)
 
MapToCircleD[Line[{-Pi, Pi}], Private`z_] := I*Exp[I*Private`z]
 
MapToCircleD[Private`l_Line, Private`z_] := 
    MapToCircleD[Private`PeriodicInterval, 
      MapToInterval[Private`l, Private`z]*Pi]*MapToIntervalD[Private`l, 
      Private`z]*Pi
 
MapToCircleD[Ellipse[{Private`a_, Private`b_}, Private`r_], Private`z_] := 
    MapToCircleD[Circle[0, Private`r], IntervalToInnerCircle[
       MapToInterval[Line[{Private`a, Private`b}], Private`z]]]*
     Derivative[1][IntervalToInnerCircle][MapToInterval[
       Line[{Private`a, Private`b}], Private`z]]*
     MapToIntervalD[Line[{Private`a, Private`b}], Private`z]
 
MapToCircleD[Private`f_LFun, Private`z_] := MapToCircleD[Domain[Private`f], 
     Private`z]
 
MapToCircleD[Private`cr:Curve[_], Private`z_] := 
    1/MapFromCircleD[Private`cr, MapToCircle[Private`cr, Private`z]]
 
MapToCircleD /: MapToCircleD::usage = 
     "MapToCircleD[d,z] is the derivative of MapToCircle[d,z]."
 
Attributes[MapToIntervalD] = {Listable}
 
MapToIntervalD[Line[{_?InfinityQ, _?InfinityQ}], Private`y_] := 
    Derivative[1][RealLineToInterval][Private`y]
 
MapToIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}, 
      Stretch -> Private`L_], Private`z_] := 
    (2*E^(I*Arg[Private`b])*Private`L)/
     (-Private`a + E^(I*Arg[Private`b])*Private`L + Private`z)^2
 
MapToIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}, 
      Stretch -> Private`L_], Private`z_] := 
    -MapToIntervalD[Line[{Private`b, Private`a}, Stretch -> Private`L], 
      Private`z]
 
MapToIntervalD[Line[{(Private`a_)?NumberQ, (Private`b_)?InfinityQ}], 
     Private`z_] := MapToIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToIntervalD[Line[{(Private`a_)?InfinityQ, (Private`b_)?NumberQ}], 
     Private`z_] := MapToIntervalD[Line[{Private`a, Private`b}, 
      Stretch -> 1.], Private`z]
 
MapToIntervalD[Line[{Private`a_, Private`b_}], Private`x_] := 
    -(2/(Private`a - Private`b))
 
MapToIntervalD[Line[{Private`a_, Private`b_}, Stretch -> Private`L_], 
     Private`z_] := -((2*(Private`a*Private`L - Private`b*Private`L))/
      (Private`a - Private`b*Private`L - Private`z + Private`L*Private`z)^2)
 
MapToIntervalD[Arc[Private`z0_, Private`r_, {Private`t0_, Private`t1_}], 
     Private`z_] := (2*E^((I*Private`t0)/2)*(E^(I*Private`t1) + 
       E^((1*I*(Private`t0 + Private`t1))/2))*Private`r)/
     ((-E^((I*Private`t0)/2) + E^((I*Private`t1)/2))*
      (E^((1*I*(Private`t0 + Private`t1))/2)*Private`r + Private`z - 
        Private`z0)^2)
 
MapToIntervalD[Private`f_IFun, Private`z_] := 
    MapToIntervalD[Domain[Private`f], Private`z]
 
MapToIntervalD[Private`cr:Curve[_], Private`z_] := 
    1/MapFromIntervalD[Private`cr, MapToInterval[Private`cr, Private`z]]
 
MapToIntervalD[Curve[Private`cr_IFun, Stretch -> Private`L_], Private`z_] := 
    MapToIntervalD[Line[{-1, 1}, Stretch -> Private`L], 
      MapToInterval[Curve[Private`cr], Private`z]]/
     MapFromIntervalD[Curve[Private`cr], MapToInterval[Curve[Private`cr], 
       Private`z]]
 
MapToIntervalD /: MapToIntervalD::usage = 
     "MapToIntervalD[d,x] is the derivative of MapToInterval[d,x]."
 
ShiftLeft[Private`f_ShiftList] := ShiftList[ToList[Private`f], 
     Index[Private`f] + 1]
 
ShiftLeft[Private`f_ShiftList, Private`d_] := ShiftList[ToList[Private`f], 
     Index[Private`f] + Private`d]
 
ShiftLeft[Private`l_List] := Rest[Private`l]
 
ShiftLeft[Private`l_List, Private`k_] := Private`l[[Private`k + 1 ;; All]]
 
MapOuter[Private`m_, Private`lst_] := MapIndexed[
     SDot[Private`m[First[#2]], #1] & , Private`lst]
 
SDot[Private`f_List, Private`g_List] := Private`f . Private`g
 
SDot[Private`f_, Private`g_] := Private`f*Private`g
 
BoundedIntegrate[(Private`lf_LFun)?UnitCircleFunQ] := 
    LFun[InverseFFT[MakeFFTIndexRange[MapOuter[If[ZeroQ[#1], 0, 1/#1] & , 
        ShiftRight[FFT[Private`lf]]]]], Domain[Private`lf]]
 
BoundedIntegrate[Private`lf_LFun] := SetDomain[BoundedIntegrate[
      ToUnitCircle[Private`lf]*
       LFun[Piecewise[{{0, InfinityQ[MapFromCircle[Private`lf, #1]]}, 
           {MapFromCircleD[Private`lf, #1], True}}] & , UnitCircle, 
        Length[Private`lf]]], Domain[Private`lf]]
 
BoundedIntegrate /: BoundedIntegrate::usage = 
     "BoundedIntegrate[lf] integrates an LFun with its -1 coefficient \
removed"
 
UnitCircleFunQ[Private`f_LFun] := N[Domain[Private`f]] == N[UnitCircle]
 
UnitCircleFunQ[_] := False
 
UnitCircleFunQ /: UnitCircleFunQ::usage = 
     "Tests whether an object is an LFun whose domain is the unit circle."
 
MakeFFTIndexRange[Private`sl_ShiftList] := SetIndexRange[Private`sl, 
     {-1, 1}*Max[Abs[IndexRange[Private`sl]]]]
 
ShiftRight[Private`f_ShiftList] := ShiftList[ToList[Private`f], 
     Index[Private`f] - 1]
 
ShiftRight[Private`f_ShiftList, Private`d_] := ShiftList[ToList[Private`f], 
     Index[Private`f] - Private`d]
 
ShiftRight[Private`l_List] := Join[{0}, Most[Private`l]]
 
SetDomain[(Private`f_)?FunQ, (Private`d_)?FunQ] := 
    SetDomain[Private`f, Domain[Private`d]]
 
SetDomain[(Private`f_)?FunQ, (Private`d_)?DomainQ] := 
    Head[Private`f][Values[Private`f], Private`d]
 
SetDomain[Private`f_List, Private`d_List] := (SetDomain @@ #1 & ) /@ 
     Thread[{Private`f, Private`d}]
 
SetDomain[Private`op_Private`FunValueListOperator, Private`d_] := 
    Private`FunValueListOperator[Private`op[[1]], SetDomain[Private`op[[2]], 
      Private`d]]
 
SetDomain /: SetDomain::usage = 
     "SetDomain[f,d] changes the domain of the Fun (or List of Funs) f to d"
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?ScalarFunQ}] := FromValueList[Private`g, 
     Private`mat . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?VectorFunQ}] := FromValueList[(({0, 0} & ) /@ #1 & ) /@ 
      Private`g, ScalarToVectorMatrix[Private`mat] . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_, Private`g_][
     Private`f:{__?MatrixFunQ}] := FromValueList[
     (({{0, 0}, {0, 0}} & ) /@ #1 & ) /@ Private`g, 
     ScalarToMatrixMatrix[Private`mat] . ToValueList[Private`f]]
 
Private`FunValueListOperator[Private`mat_][Private`f_] := 
    Private`FunValueListOperator[Private`mat, Private`f][Private`f]
 
FromValueList[(Private`f_IFun)?ScalarFunQ, Private`ls_] := 
    ZeroAtInfinityIFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_IFun)?VectorFunQ, Private`ls_] := 
    ToArrayFun[(ZeroAtInfinityIFun[#1, Domain[Private`f]] & ) /@ 
      Partition[Private`ls, FiniteLength[Private`f]]]
 
FromValueList[(Private`f_IFun)?MatrixFunQ, Private`ls_] := 
    ToArrayFun[MatrixMap[ZeroAtInfinityIFun[#1, Domain[Private`f]] & , 
      PartitionList[Partition[Private`ls, FiniteLength[Private`f]], 
       Dimensions[Private`f]]]]
 
FromValueList[(Private`f_LFun)?ScalarFunQ, Private`ls_] := 
    ZeroAtInfinityLFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_LFun)?MatrixFunQ, Private`ls_] := 
    ToArrayFun[MatrixMap[ZeroAtInfinityLFun[#1, Domain[Private`f]] & , 
      PartitionList[Partition[Private`ls, FiniteLength[Private`f]], 
       Dimensions[Private`f]]]]
 
FromValueList[(Private`f_LFun)?VectorFunQ, Private`ls_] := 
    ToArrayFun[(ZeroAtInfinityLFun[#1, Domain[Private`f]] & ) /@ 
      Partition[Private`ls, FiniteLength[Private`f]]]
 
FromValueList[(Private`f_PFun)?ScalarFunQ, Private`ls_] := 
    PFun[Private`ls, Domain[Private`f]]
 
FromValueList[(Private`f_PFun)?MatrixFunQ, Private`ls_] := 
    PFun[{PartitionList[Private`ls, Dimensions[Private`f]]}, 
     Domain[Private`f]]
 
FromValueList[(Private`f_PFun)?VectorFunQ, Private`ls_] := 
    PFun[{Private`ls}, Domain[Private`f]]
 
FromValueList[(Private`GI_List)?(VectorFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, ToListOfArrays /@ Thread[PartitionList[
          PartitionList[Private`ls, Flatten[ArrayMap[FiniteLength, 
             ToArrayOfListOfFuns[Private`GI]]]], Length /@ 
           ToArrayOfLists[ToArrayOfFuns /@ Private`GI]]]}]
 
FromValueList[(Private`GI_List)?(MatrixFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, ToListOfMatrices /@ ToListOfMatrices[
         PartitionList[Partition[PartitionList[Private`ls, 
            Flatten[ArrayMap[FiniteLength, ToArrayOfListOfFuns[
               Private`GI]]]], Length[Private`GI]], Dimensions[
           First[Private`GI]]]]}]
 
FromValueList[(Private`GI_List)?(ScalarFunQ[First[#1]] & ), Private`ls_] := 
    (ZeroAtInfinityFun[#1[[2]], Domain[#1[[1]]]] & ) /@ 
     Thread[{Private`GI, PartitionList[Private`ls, FiniteLength /@ 
         Private`GI]}]
 
ZeroAtInfinityIFun[Private`ls_List, (Private`d_)?LeftEndpointInfinityQ] := 
    IFun[Join[{0*Private`ls[[1]]}, Private`ls], Private`d]
 
ZeroAtInfinityIFun[Private`ls_List, (Private`d_)?RightEndpointInfinityQ] := 
    IFun[Join[Private`ls, {0*Private`ls[[1]]}], Private`d]
 
ZeroAtInfinityIFun[Private`ls_List, Private`d_] := IFun[Private`ls, Private`d]
 
ZeroAtInfinityIFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := IFun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityIFun /: ZeroAtInfinityIFun::usage = 
     "Constructs a Fun with the default value of zero at infinity"
 
FiniteLength[Private`f_] := Length[FinitePoints[Private`f]]
 
PartitionList[Private`l_, {}] := {}
 
PartitionList[Private`l_, (Private`d_)?VectorQ] := 
    Join[{Private`l[[1 ;; First[Private`d]]]}, 
     PartitionList[Private`l[[First[Private`d] + 1 ;; -1]], Rest[Private`d]]]
 
PartitionList[Private`l_, (Private`d_)?MatrixQ] := 
    PartitionList[PartitionList[Private`l, Flatten[Private`d]], 
     Length /@ Private`d]
 
ZeroAtInfinityLFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := LFun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityLFun[Private`f_List, Line[{-Infinity, Infinity}]] := 
    LFun[Join[{0*Private`f[[1]]}, Private`f], RealLine]
 
ZeroAtInfinityLFun[Private`f_List, Private`d_] := LFun[Private`f, Private`d]
 
ZeroAtInfinityLFun /: ZeroAtInfinityLFun::usage = 
     "Constructs a LFun with the default value of zero at infinity"
 
RealLine = Line[{-Infinity, Infinity}]
 
RealLine /: RealLine::usage = "The real line Line[{-\[Infinity],\[Infinity]}]"
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?IntervalDomainQ] := 
    ZeroAtInfinityIFun[Private`f, Private`d]
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?CircleDomainQ] := 
    ZeroAtInfinityLFun[Private`f, Private`d]
 
ZeroAtInfinityFun[Private`f_List, (Private`d_)?PointDomainQ] := 
    PFun[Private`f, Private`d]
 
ZeroAtInfinityFun[(Private`f_)?NotListOrPatternQ, Private`d_, 
     Private`opts___] := Fun[If[InfinityQ[#1], 0*Private`f[0.], 
       Private`f[#1] /. Underflow[] -> 0] & , Private`d, Private`opts]
 
ZeroAtInfinityFun /: ZeroAtInfinityFun::usage = 
     "Constructs a Fun with the default value of zero at infinity"
 
ToArrayOfListOfFuns[Private`f_List] := ToArrayOfLists[
     ToArrayOfFuns /@ Private`f]
 
ToValueList[Private`GI_List] := Flatten[(ArrayMap[FiniteValues, #1] & ) /@ 
      ToArrayOfLists[ToArrayOfFuns /@ Private`GI]]
 
ToValueList[(Private`f_)?FunQ] := Flatten[ArrayMap[FiniteValues, 
      ToArrayOfFuns[Private`f]]]
 
ScalarToVectorMatrix := BlockDiagonalMatrix[{#1, #1}] & 
 
BlockDiagonalMatrix[Private`Al_List] := 
    Module[{Private`Asp, Private`k, Private`j, Private`dim, Private`sete}, 
     Private`dim[(Private`al_)?MatrixQ] := Dimensions[Private`al]; 
      Private`dim[(Private`al_)?VectorQ] := {Length[Private`al], 1}; 
      Private`dim[Private`al_] := {1, 1}; Private`Asp = 
       SparseZeroMatrix @@ Total[Private`dim /@ Private`Al]; 
      {Private`k, Private`j} = {0, 0}; Private`sete[(Private`A_)?MatrixQ] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 
            Dimensions[Private`A][[1]]),Private`j + 1 ;; 
          (Private`j = Private`j + Dimensions[Private`A][[2]])]] = Private`A; 
      Private`sete[(Private`A_)?VectorQ] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 
            Length[Private`A]),Private`j + 1 ;; (Private`j = 
           Private`j + 1)]] = Private`A; Private`sete[Private`A_] := 
       Private`Asp[[Private`k + 1 ;; (Private`k = Private`k + 1),
         Private`j + 1 ;; (Private`j = Private`j + 1)]] = Private`A; 
      Private`sete /@ Private`Al; Private`Asp]
 
SparseZeroMatrix[Private`n_, Private`m_] := SparseArray[{}, 
     {Private`n, Private`m}]
 
ScalarToMatrixMatrix := BlockDiagonalMatrix[{#1, #1, #1, #1}] & 
 
ToUnitCircle[Private`lf_LFun] := SetDomain[Private`lf, UnitCircle]
 
ToUnitCircle /: ToUnitCircle::usage = 
     "ToUnitCircle[lfun] maps lfun to an LFun defined over the unit circle."
 
RemoveZeros[{Private`v___, _?(Norm[#1] == 0 & )}] := RemoveZeros[{Private`v}]
 
RemoveZeros[Private`v_List] := Private`v
 
RemoveZeros[ShiftList[{Private`v___, _?(Norm[#1] == 0 & )}, Private`ind_]] := 
    RemoveZeros[ShiftList[{Private`v}, Private`ind]]
 
RemoveZeros[ShiftList[{_?(Norm[#1] == 0 & ), Private`v___}, Private`ind_]] := 
    RemoveZeros[ShiftList[{Private`v}, Private`ind - 1]]
 
RemoveZeros[Private`v_ShiftList] := Private`v
 
$MachineTolerance = 1.*^-13
 
$MachineTolerance /: $MachineTolerance::usage = "A specified tolerance for \
when two numerical values should be treated as equal."
 
Private`AdaptiveLFun[Private`m_Integer, Private`f_, Private`d_, 
     Private`pars:OptionsPattern[]] := Module[{Private`prec}, 
     Private`prec = InterpolationPrecision /. {Private`pars} /. 
        Options[Private`AdaptiveLFun]; LFun[Private`f, Private`d, 
       Length[ChopDrop[(If[Max[Abs[Flatten[ToList[FFT[#1]][[{1, 2, -1, 
                  -2}]]]]] < Private`prec, #1, Private`AdaptiveLFun[
             2*Private`m, Private`f, Private`d, Private`pars]] & )[
          LFun[Private`f, Private`d, Private`m]], Private`prec]]]]
 
Options[Private`AdaptiveLFun] := {InterpolationPrecision -> $MachineTolerance}
 
ChopDrop[Private`cf_IFun] := 
    IFun[InverseDCT[(Which[Length[#1] == 0, {0, 0}, Length[#1] == 1, 
         {#1[[1]], 0*#1[[1]]}, True, #1] & )[ChopDrop[DCT[Private`cf]]]], 
     Domain[Private`cf]]
 
ChopDrop[Private`cf_LFun] := 
    LFun[InverseFFT[(SetIndexRange[#1, {-Max[Abs[IndexRange[#1]]], 
          Max[Abs[IndexRange[#1]]]}] & )[
       (Which[Length[#1] == 0, ShiftList[{0, 0, 0}, 2], IndexRange[#1] == 
           {0, 0}, ShiftList[{0*#1[[0]], #1[[0]], 0*#1[[0]]}, 2], True, 
          #1] & )[ChopDrop[FFT[Private`cf]]]]], Domain[Private`cf]]
 
ChopDrop[Private`v_] := RemoveZeros[Chop[Private`v]]
 
ChopDrop[Private`cf_IFun, Private`prec_] := 
    IFun[InverseDCT[(Which[Length[#1] == 0, {0, 0}, Length[#1] == 1, 
         {#1[[1]], 0*#1[[1]]}, True, #1] & )[ChopDrop[DCT[Private`cf], 
        Private`prec]]], Domain[Private`cf]]
 
ChopDrop[Private`cf_LFun, Private`prec_] := 
    LFun[InverseFFT[(SetIndexRange[#1, {-Max[Abs[IndexRange[#1]]], 
          Max[Abs[IndexRange[#1]]]}] & )[
       (Which[Length[#1] == 0, ShiftList[{0, 0, 0}, 2], IndexRange[#1] == 
           {0, 0}, ShiftList[{0*#1[[0]], #1[[0]], 0*#1[[0]]}, 2], True, 
          #1] & )[ChopDrop[FFT[Private`cf], Private`prec]]]], 
     Domain[Private`cf]]
 
ChopDrop[Private`v_, Private`prec_] := RemoveZeros[
     Chop[Private`v, Private`prec]]
 
NZeroQ[Private`sl_List] := NZeroQ[Max[Abs[Private`sl]]]
 
NZeroQ[Private`sl_ShiftList] := NZeroQ[ToList[Private`sl]]
 
NZeroQ[Private`f_] := NEqual[Private`f, 0]
 
ChebyshevLobattoDerivative[Private`c_List] := 
    InverseDCT[ChebyshevD[DCT[Private`c]]]
 
ChebyshevLobattoDerivative /: ChebyshevLobattoDerivative::usage = "Maps a \
list of function values at Chebyshev points to those of its derivative."
 
ChebyshevD[Private`c_List] := Module[{Private`d, Private`n}, 
     Private`n = Length[Private`c]; If[Private`n == 1, {0*Private`c[[1]]}, 
       Private`d[Private`n] = Private`d[Private`n - 1] = 0*Private`c[[1]]; 
        Do[Private`d[Private`k] = Private`d[Private`k + 2] + 
           2*(Private`k + 1)*Private`c[[Private`k + 2]], 
         {Private`k, Private`n - 2, 1, -1}]; Private`d[0] = 
         Private`d[2]/2 + Private`c[[2]]; Array[Private`d[#1 - 1] & , 
         {Private`n}]]]
 
ChebyshevD /: ChebyshevD::usage = 
     "Maps a list of Chebyshev coefficients to those of its derivative."
 
ChebyshevLobattoIntegrate[Private`c_List] := 
    InverseDCT[ChebyshevI[DCT[Private`c]]]
 
ChebyshevLobattoIntegrate /: ChebyshevLobattoIntegrate::usage = "Maps a list \
of function values at Chebyshev points to those of its indefinite integral."
 
ChebyshevI[Private`c_List] := Module[{Private`c2}, 
     Private`c2 = ZeroVector[Length[Private`c] + 1]; 
      Private`c2[[2]] = Private`c[[1]]; Private`c2[[1]] = Private`c[[1]]; 
      If[Length[Private`c] > 1, Private`c2[[3]] = Private`c[[2]]/4; 
        Private`c2[[1]] = Private`c2[[1]] - Private`c[[2]]/4; 
        Table[Private`c2[[Private`k + 1]] = Private`c2[[Private`k + 1]] + 
            Private`c[[Private`k]]/(2*Private`k); 
          Private`c2[[Private`k - 1]] = Private`c2[[Private`k - 1]] - 
            Private`c[[Private`k]]/(2*(Private`k - 2)); Private`c2[[1]] = 
           Private`c2[[1]] + (-1)^Private`k*Private`c[[Private`k]]*
             (1/(2*(Private`k - 2)) - 1/(2*Private`k)); , 
         {Private`k, 3, Length[Private`c]}]]; Private`c2]
 
ChebyshevI /: ChebyshevI::usage = 
     "Maps a list of Chebyshev coefficients to those of its indefinite \
integral."
 
ZeroVector[Private`n_] := Table[0, {Private`n}]
 
ZeroVector /: ZeroVector::usage = 
     "ZeroVector[n] constructs a vector of length n of all zeros."
 
ComplexRoots[(Private`cf_IFun)?UnitIntervalFunQ] := 
    Module[{Private`dct}, Private`dct = RemoveZeros[Chop[DCT[Private`cf], 
         $MachineTolerance]]; Which[Length[Private`dct] <= 1, {}, 
       Length[Private`dct] == 2, {-(Private`dct[[1]]/Private`dct[[2]])}, 
       True, Eigenvalues[-PadLeft[{Most[Private`dct]/(2*Last[Private`dct])}, 
           {Length[Private`dct] - 1, Length[Private`dct] - 1}] + 
         SparseArray[{{1, 2} -> 1, {Private`i_, Private`j_} /; 
             Private`j == Private`i + 1 -> 0.5, {Private`i_, Private`j_} /; 
             Private`j == Private`i - 1 -> 0.5}, {Length[Private`dct] - 1, 
           Length[Private`dct] - 1}]]]]
 
ComplexRoots[Private`cf_IFun] := MapFromInterval[Private`cf, 
     ComplexRoots[ToUnitInterval[Private`cf]]]
 
ComplexRoots[Private`lf_LFun] := ComplexRoots[Domain[Private`lf], 
     ChopDrop[FFT[Private`lf], $MachineTolerance]]
 
ComplexRoots[Private`d_, (Private`fft_ShiftList)?(Length[#1] == 1 & )] := 
    Which[Index[Private`fft] == 1, {}, Index[Private`fft] > 1, Infinity, 
     True, 0]
 
ComplexRoots[Private`d_, (Private`fft_ShiftList)?(Length[#1] == 2 & )] := 
    Module[{Private`dct}, Private`dct = ToList[Private`fft]; 
      {-(Private`dct[[1]]/Private`dct[[2]])}]
 
ComplexRoots[Private`d_, Private`fft_ShiftList] := 
    Module[{Private`dct}, Private`dct = ToList[Private`fft]; 
      MapFromCircle[Private`d, Eigenvalues[
        N[Normal[Transpose[Join[Transpose[SparseArray[{Private`i_, 
                 Private`j_} /; Private`j == Private`i - 1 -> 1, 
              {Length[Private`dct] - 1, Length[Private`dct] - 2}]], 
            -({Most[Private`dct]}/Last[Private`dct])]]]]]]]
 
ComplexRoots /: ComplexRoots::usage = "Returns all roots"
 
UnitIntervalFunQ[Private`f_IFun] := N[Domain[Private`f]] === N[UnitInterval]
 
UnitIntervalFunQ[_] := False
 
UnitIntervalFunQ /: UnitIntervalFunQ::usage = 
     "Tests whether an object is an IFun whose domain is the unit interval."
 
ToUnitInterval[Private`lf_IFun] := SetDomain[Private`lf, UnitInterval]
 
ToUnitInterval /: ToUnitInterval::usage = 
     "ToUnitInterval[ifun] maps ifun to an IFun defined over the unit \
interval."
 
Endpoints[Private`GG_IFun] := {Chop[N[LeftEndpoint[Private`GG]]], 
      Chop[N[RightEndpoint[Private`GG]]]} /. _?InfinityQ -> Infinity
 
Endpoints[Private`GG_List] := Union[Flatten[Endpoints /@ Private`GG], 
     SameTest -> NEqual]
 
Endpoints /: Endpoints::usage = "Returns all endpoints of a list of funs"
 
Private`AdaptiveIFun[Private`m_Integer, Private`f_, Private`d_, 
     Private`pars:OptionsPattern[]] := Module[{Private`prec}, 
     Private`prec = InterpolationPrecision /. {Private`pars} /. 
        Options[Private`AdaptiveIFun]; 
      (IFun[Private`f, Private`d, Length[#1]] & )[
       (ChopDrop[#1, Private`prec*Max[$MachineTolerance, 
            Norm /@ Values[#1]]] & )[
        (If[Max[Abs[Flatten[DCT[#1][[-2 ;; -1]]]]] < Private`prec*
             Max[$MachineTolerance, Norm /@ Values[#1]], #1, 
           Private`AdaptiveIFun[2*Private`m, Private`f, Private`d, 
            Private`pars]] & )[IFun[Private`f, Private`d, Private`m]]]]]
 
Options[Private`AdaptiveIFun] := {InterpolationPrecision -> $MachineTolerance}
 
SignChange[Private`x_, Private`y_] := If[Sign[Private`x]*Sign[Private`y] == 
      -1, True, False]
 
CreateDomains[Private`V_] := Module[{Private`i, Private`out}, 
     Private`out = {}; For[Private`i = 1, Private`i <= Length[Private`V], 
       Private`i = Private`i, If[Private`V[[Private`i,2]] == 1, 
         Private`out = Join[Private`out, {Line[{Private`V[[Private`i,1]], 
               Private`V[[Private`i + 1,1]]}]}]; Private`i = Private`i + 2; , 
         Private`i = Private`i + 1; ]; ]; Private`out]
 
\[Theta][k_, x_, t_] := I*k*x - I*k^2*t
 
q0h1[k_] := q0hnl[k]
 
q0hnl[k_] := LevinInt[my1f[k], my1g[k], my1dg[k], 0, 50, nfwd, 1, False]
 
LevinInt[f_, g_, dg_, r0_, r1_, n_, trunc_, check_] := 
    Module[{f3b3, ans, IIm, IImb, id, A, rhs, mu, f3b3trundom, f3b3exact, 
      newr0, newr1}, f3b3trundom = Truncate[tol][{f[#1] & , Line[{r0, r1}], 
         n}]; If[f3b3trundom == {}, ans = 0, 
       f3b3 = Fun[f[#1] & , f3b3trundom, n][[1]]; Last[Values[f3b3]]; 
        newr1 = f3b3trundom[[1]][[1]][[2]]; newr0 = f3b3trundom[[1]][[1]][[
          1]]; IIm = ReduceDimensionIntegrateMatrix[f3b3]; 
        IImb = Reverse[Transpose[Reverse[Transpose[
             ReduceDimensionIntegrateMatrix[ReverseOrientation[f3b3]]]]]]; 
        id = IdentityMatrix[n]; A = id + IImb . DiagonalMatrix[
            Values[Fun[dg[#1] & , Line[{r0, r1}], n]]]; 
        rhs = IImb . Values[f3b3]; mu = LinearSolve[A, rhs]; 
        ans = mu[[n]]*Exp[g[newr1]] - mu[[1]]*Exp[g[newr0]]; 
        If[r1 == Infinity, ans = (-mu[[1]])*Exp[g[r0]]]; 
        If[check, Print[{"DOM", f3b3trundom, "CDN", 
            Norm[A]*Norm[Inverse[A]]}]; f3b3exact = NIntegrate[
            f[k]*Exp[g[k]], {k, r0, r1}, Method -> "LevinRule"]; 
          {ans, "Levin"}; {f3b3exact, "NInt"}; ans - f3b3exact; 
          Abs[ans - f3b3exact]/Abs[f3b3exact]; {f3b3, DCTPlot[f3b3]}; ]; 
        If[check, {ans, f3b3exact}, ans]]]
 
ReduceDimensionIntegrateMatrix[(Private`d_)?DomainQ, Private`n_Integer] := 
    ReduceDimensionMatrix[Private`d, Private`n + 1] . 
     IntegrateMatrix[Private`d, Private`n]
 
ReduceDimensionIntegrateMatrix[Private`f_] := ReduceDimensionIntegrateMatrix[
     Domain[Private`f], Length[Private`f]]
 
ReduceDimensionMatrix[Private`d_, Private`n_] := 
    Inverse[TransformMatrix[Private`d, Private`n - 1]] . 
     IdentityMatrix[Private`n][[1 ;; -2,All]] . TransformMatrix[Private`d, 
      Private`n]
 
ReduceDimensionMatrix[Private`f_] := ReduceDimensionMatrix[Domain[Private`f], 
     Length[Private`f]]
 
TransformMatrix[_?IntervalDomainQ, Private`n_Integer] := 
    Private`DCTTransformMatrix[Private`n]
 
TransformMatrix[_?CircleDomainQ, Private`n_Integer] := 
    Private`FFTTransformMatrix[Private`n]
 
TransformMatrix[(Private`f_)?FunQ] := TransformMatrix[Domain[Private`f], 
     Length[Private`f]]
 
Private`DCTTransformMatrix[Private`n_Integer] := 
    ColumnMap[DCT, IdentityMatrix[Private`n]]
 
ColumnMap[Private`f_, (Private`m_)?VectorQ] := 
    VectorTranspose[Private`f /@ Private`m]
 
ColumnMap[Private`f_, (Private`m_)?MatrixQ] := 
    VectorTranspose[Private`f /@ Transpose[Private`m]]
 
VectorTranspose[(Private`f_)?MatrixQ] := Transpose[Private`f]
 
VectorTranspose[Private`f_] := Private`f
 
Private`FFTTransformMatrix[Private`n_Integer] := 
    ColumnMap[ToList[FFT[#1]] & , IdentityMatrix[Private`n]]
 
IntegrateMatrix[(Private`d_)?IntervalDomainQ, Private`n_Integer] := 
    ColumnMap[ChebyshevLobattoIntegrate, IdentityMatrix[Private`n]] . 
     DiagonalMatrix[MapFromIntervalD[Private`d, Points[UnitInterval, 
        Private`n]]]
 
IntegrateMatrix[Private`f_] := IntegrateMatrix[Domain[Private`f], 
     Length[Private`f]]
 
ReverseOrientation[Line[{Private`a_, Private`b_}, Private`l___]] := 
    Line[{Private`b, Private`a}, Private`l]
 
ReverseOrientation[Arc[Private`z0_, Private`r_, {Private`t0_, 
       Private`t1_}]] := Arc[Private`z0, Private`r, {Private`t1, Private`t0}]
 
ReverseOrientation[Private`f_IFun] := IFun[Reverse[Values[Private`f]], 
     ReverseOrientation[Domain[Private`f]]]
 
ReverseOrientation[Curve[Private`cr_IFun, Private`opts___]] := 
    Curve[Head[Private`cr][Reverse[Values[Private`cr]], Domain[Private`cr]], 
     Private`opts]
 
ReverseOrientation /: ReverseOrientation::usage = 
     "ReverseOrientation[ifun] gives ifun with the orientation reversed."
 
DCTPlot[Private`f_IFun, Private`opts:OptionsPattern[]] := 
    ListLineLogPlot[Norm /@ DCT[Private`f], Private`opts]
 
DCTPlot /: DCTPlot::usage = 
     "LogPlots the norm of the Chebyshev coefficients of an IFun"
 
Attributes[ListLineLogPlot] = {HoldFirst}
 
ListLineLogPlot[Private`h_, Private`opts___] := ListLogPlot[Private`h, 
     Joined -> True, Private`opts]
 
ListLineLogPlot /: ListLineLogPlot::usage = 
     "Like LineLogPlot, but with a logarithmic scale"
 
my1f[k_][x_] := q0[x]*Exp[(-I)*I*Im[k]*x]
 
q0[_?InfinityQ] := 0
 
q0[x_] := Exp[-x]
 
my1g[k_][x_] := (-I)*Re[k]*x
 
my1dg[k_][x_] := (-I)*Re[k]
 
nfwd = 20
 
f1dtrundom2 = {Line[{0.45499999999999996 + 0.04500000000000001*I, 
       0.5 + 0.*I}]}
 
f1dtrundom3 = {Line[{0.5 + 0.*I, 0.7949999999999999 - 0.29499999999999993*I}]}
 
f1d1 = {}
 
f1d2 = {IFun[{5.480416837757504*^-16 + 8.006059826858011*^-15*I, 
       5.858887193908404*^-16 + 8.55635390376184*^-15*I, 
       7.1535645634784*^-16 + 1.0437634024005696*^-14*I, 
       9.955155109682945*^-16 + 1.4503531027493958*^-14*I, 
       1.5737149195857754*^-15 + 2.2879283203324212*^-14*I, 
       2.812764281219035*^-15 + 4.078408587897583*^-14*I, 
       5.6508937752219925*^-15 + 8.167205370803449*^-14*I, 
       1.2671578170326383*^-14 + 1.824537661736146*^-13*I, 
       3.1461203253584996*^-14 + 4.510663371689438*^-13*I, 
       8.571336795117322*^-14 + 1.223053167755455*^-12*I, 
       2.537451177675657*^-13 + 3.6018659128292118*^-12*I, 
       8.077514018747516*^-13 + 1.1401333227394994*^-11*I, 
       2.7347198375978765*^-12 + 3.8367921479390367*^-11*I, 
       9.735552542632338*^-12 + 1.3571820275935134*^-10*I, 
       3.602281486142721*^-11 + 4.988125697883968*^-10*I, 
       1.3692603125192282*^-10 + 1.882800100749957*^-9*I, 
       5.284928537537752*^-10 + 7.2145330069330975*^-9*I, 
       2.0477934210276275*^-9 + 2.7746934109003306*^-8*I, 
       7.878329879232311*^-9 + 1.0593707730359081*^-7*I, 
       2.9778723305513236*^-8 + 3.9732614419036273*^-7*I, 
       1.0949594056828071*^-7 + 1.4495159884542983*^-6*I, 
       3.8808274947995294*^-7 + 5.096904315722968*^-6*I, 
       1.314813620397264*^-6 + 0.000017131368440306983*I, 
       4.226667221696604*^-6 + 0.000054635521314390644*I, 
       0.000012809672432301585 + 0.00016427900584691473*I, 
       0.00003640414463759929 + 0.0004632266438999157*I, 
       0.0000965991340434898 + 0.0012197181031447662*I, 
       0.00023857209287156509 + 0.002989557407016356*I, 
       0.0005472451890691809 + 0.006806748111240815*I, 
       0.0011647204372022485 + 0.014382376619074242*I, 
       0.0023001422259775854 + 0.028203714232516275*I, 
       0.004219185136638767 + 0.05138356951119755*I, 0.007202664460930052 + 
        0.08714537358431468*I, 0.011475387548679786 + 0.13797258705485158*I, 
       0.01712360300048177 + 0.20465503551438075*I, 0.024032699832140972 + 
        0.2856055801382815*I, 0.03187482656920865 + 0.37678244654161375*I, 
       0.04015773706610645 + 0.4723228002768038*I, 0.04832043876472544 + 
        0.565693586527919*I, 0.055842824892373466 + 0.6509648017842377*I, 
       0.06233450892062986 + 0.7238058601527386*I, 0.06758102254945192 + 
        0.781969054157825*I, 0.07154418769779725 + 0.825243109860855*I, 
       0.07432820488995656 + 0.8550245967201249*I, 0.07612907758315307 + 
        0.8737161174320542*I, 0.07718320301038928 + 0.8841319373175437*I, 
       0.0777250390876737 + 0.8890194711155689*I, 0.07795744363686669 + 
        0.890731738649596*I, 0.07803376359358366 + 0.8910352694888813*I, 
       0.07804858010433902 + 0.8910148622747424*I}, 
      Line[{0.45499999999999996 + 0.04500000000000001*I, 0.5 + 0.*I}]]}
 
f1d3 = {IFun[{0.07804858010433902 + 0.8910148622747424*I, 
       0.0780134156117534 + 0.8893736037819611*I, 0.07654834564659224 + 
        0.8690520982076514*I, 0.0699653133033385 + 0.7888921633605924*I, 
       0.05464641831868228 + 0.6103793080453522*I, 0.03240643770636854 + 
        0.3576964844322106*I, 0.012586881756692071 + 0.13698334624981265*I, 
       0.00269000180034718 + 0.028805724144381747*I, 0.000259747260759624 + 
        0.0027318789300051823*I, 9.133128095786415*^-6 + 
        0.00009419420661836085*I, 9.292829812844804*^-8 + 
        9.385559290714592*^-7*I, 2.1545505693637966*^-10 + 
        2.1285968043389636*^-9*I, 8.928183889857319*^-14 + 
        8.620687325405434*^-13*I, 5.194280700824802*^-18 + 
        4.8984597278768206*^-17*I, 3.3560013023700726*^-23 + 
        3.089690323683901*^-22*I, 1.9285431663791635*^-29 + 
        1.7328750028373936*^-28*I, 8.036157664135181*^-37 + 
        7.046827650789793*^-36*I, 2.0255768861648703*^-45 + 
        1.7335309955251666*^-44*I, 2.6489941197470706*^-55 + 
        2.2130533672718606*^-54*I, 1.5922935245745139*^-66 + 
        1.2989909380659433*^-65*I, 4.04138438658294*^-79 + 
        3.2208793412088405*^-78*I, 4.140405451479285*^-93 + 
        3.22535763033201*^-92*I, 1.708214162664361*^-108 + 
        1.3014583717578206*^-107*I, 2.9615075663048027*^-125 + 
        2.2082230686207288*^-124*I, 2.3582917911993886*^-143 + 
        1.7221974599116712*^-142*I, 9.884182235724144*^-163 + 
        7.074757680201076*^-162*I, 2.619321554396234*^-183 + 
        1.8390388239171093*^-182*I, 5.522904182763049*^-205 + 
        3.806773598104712*^-204*I, 1.2196038914705354*^-227 + 
        8.259605171270487*^-227*I, 3.874457369314104*^-251 + 
        2.580316058897376*^-250*I, 2.5307037241645438*^-275 + 
        1.6588160159624586*^-274*I, 5.0354245082092915*^-300 + 
        3.251339173951718*^-299*I, 
       4.66739589217589880335978256519325864943192`15.954589770191005*^-325 + 
        2.97129851409422473192431416474809246706633`15.954589770191005*^-324*
         I, 3.1657296897057167325253315375805812`15.954589770191005*^-350 + 
        1.988683063614828848599288454615111208`15.954589770191005*^-349*I, 
       2.52144076870999672823355409875`15.954589770191005*^-375 + 
        1.564346212754412711237176347567`15.954589770191005*^-374*I, 
       3.8440796157917678865461113681258263532636314`15.954589770191005*^-400 \
+ 2.35743665031865191581517388795010722774939786`15.954589770191005*^-399*I, 
       1.84593699668374940970588584663649749422`15.954589770191005*^-424 + 
        1.119942410523466557989108308464369859744`15.954589770191005*^-423*I, 
       4.60877127737478103464453653997351`15.954589770191005*^-448 + 
        2.7685953487841828411458270961957162`15.954589770191005*^-447*I, 
       9.842027233188574525789431577941`15.954589770191005*^-471 + 
        5.8588822939933933329544531625894`15.954589770191005*^-470*I, 
       2.9280568042072486547872840816`15.954589770191005*^-492 + 
        1.7287155920571998453918961841`15.954589770191005*^-491*I, 
       1.944442148520933070210645908`15.954589770191005*^-512 + 
        1.1394802382691385645146564287`15.954589770191005*^-511*I, 
       4.514031382310125196654899023`15.954589770191005*^-531 + 
        2.62781357604634214425726137192`15.954589770191005*^-530*I, 
       5.574326046357020694833522608646`15.954589770191005*^-548 + 
        3.2261743468553413394783977774128`15.954589770191005*^-547*I, 
       5.3823058933917832138345015658046768`15.954589770191005*^-563 + 
        3.09937165337603432889050861867228599`15.954589770191005*^-562*I, 
       5.7395172193382470808671292708585835786007`15.954589770191005*^-576 + 
        3.29102917635516189110881053316830879409566`15.954589770191005*^-575*
         I, 9.13107134957378970942068931506`15.954589770191005*^-587 + 
        5.217578347849935701011326413793`15.954589770191005*^-586*I, 
       2.78828918743629262135360156862973250881518`15.954589770191005*^-595 + 
        1.588961408328380125576020853167395513720979`15.954589770191005*^-594*
         I, 1.9955221076076937162300738233474824`15.954589770191005*^-601 + 
        1.135001030305246579299561215817838442`15.954589770191005*^-600*I, 
       3.8681913637360662834244441172065`15.954589770191005*^-605 + 
        2.19758973115804950983957104209816`15.954589770191005*^-604*I, 
       2.216889266879242428712960986667`15.954589770191005*^-606 + 
        1.2589709996991587887078957858216`15.954589770191005*^-605*I}, 
      Line[{0.5 + 0.*I, 0.7949999999999999 - 0.29499999999999993*I}]]}
 
I1 = 0.002161193938717689 + 0.0018131784675191874*I
 
f2btrundom1 = {Line[{0.20500000000000007 + 0.29499999999999993*I, 
       0.5 + 0.*I}]}
 
f2btrundom2 = {Line[{0.5 + 0.*I, 0.545 - 0.04500000000000001*I}]}
 
f2btrundom3 = {}
 
f2b1 = {IFun[{-7.531582468670261381928663218997`15.954589770191005*^-606 + 
        1.2758403996408188541097447964003`15.954589770191005*^-605*I, 
       -1.31513681565054044060545967266873`15.954589770191005*^-604 + 
        2.22647948596676319068998125798207`15.954589770191005*^-604*I, 
       -6.79956041905368708026677616088222429`15.954589770191005*^-601 + 
        1.149059392697814969288652631711658414`15.954589770191005*^-600*I, 
       -9.53588856410018655477736193333678642637521`15.954589770191005*^-595 \
+ 1.606629384860485253421174821816420396852591`15.954589770191005*^-594*I, 
       -3.138898260506031096779699396799`15.954589770191005*^-586 + 
        5.266333237842978006171167341012`15.954589770191005*^-586*I, 
       -1.98604752495415291113022578224402188970767`15.954589770191005*^-575 \
+ 3.31426641586561484429421989204282190667548`15.954589770191005*^-575*I, 
       -1.87741403763146734449338361511453108`15.954589770191005*^-562 + 
        3.11259801412198341780858344683251849`15.954589770191005*^-562*I, 
       -1.9627713665864222539380813443883`15.954589770191005*^-547 + 
        3.2292832765093276959198407260495`15.954589770191005*^-547*I, 
       -1.60666182425820879650969610979`15.954589770191005*^-530 + 
        2.62032094828879062135702918646`15.954589770191005*^-530*I, 
       -7.005211738345650403765609344`15.954589770191005*^-512 + 
        1.1313015831348448697767928788`15.954589770191005*^-511*I, 
       -1.06915656431493076072515702505`15.954589770191005*^-491 + 
        1.70794582983862661955438428037`15.954589770191005*^-491*I, 
       -3.646995780390161125778589062568`15.954589770191005*^-470 + 
        5.7571669152430238842734915398152`15.954589770191005*^-470*I, 
       -1.7352475198487475455459967511404284`15.954589770191005*^-447 + 
        2.7043257282038982584020803626453638`15.954589770191005*^-447*I, 
       -7.07027207974908599663598321564605813073`15.954589770191005*^-424 + 
        1.086826840952855848682622754097422544053`15.954589770191005*^-423*I, 
       -1.49952290805165647996479942178048942420700251`15.954589770191005*^-3\
99 + 2.27157782575632509976244578818855010010623804`15.954589770191005*^-399*
         I, -1.002834335710157704624325104558`15.954589770191005*^-374 + 
        1.495890715110354387246418092472`15.954589770191005*^-374*I, 
       -1.285084663812870938355706059166131844`15.954589770191005*^-349 + 
        1.886113772497378201007964121771377224`15.954589770191005*^-349*I, 
       -1.935728720666581215422094374312088548709107`15.954589770191005*^-324 \
+ 2.793446161051371820853955134535942496442906`15.954589770191005*^-324*I, 
       -2.135651511885359*^-299 + 3.0283490484448413*^-299*I, 
       -1.0986263903694704*^-274 + 1.5298621407157364*^-274*I, 
       -1.7230521567840757*^-250 + 2.355064551863597*^-250*I, 
       -5.560651413265464*^-227 + 7.456527757862518*^-227*I, 
       -2.5835063894909097*^-204 + 3.3975169583750354*^-204*I, 
       -1.257922763054437*^-182 + 1.621859058360034*^-182*I, 
       -4.876300733211154*^-162 + 6.162465806321991*^-162*I, 
       -1.1958186141313089*^-142 + 1.481034144370903*^-142*I, 
       -1.5441898710683249*^-124 + 1.8741345499989584*^-124*I, 
       -9.162659477066304*^-108 + 1.0897354990183177*^-107*I, 
       -2.2853320379503607*^-92 + 2.663683152923493*^-92*I, 
       -2.2959545640386644*^-78 + 2.623012541544943*^-78*I, 
       -9.311990874814106*^-66 + 1.0430137546130855*^-65*I, 
       -1.594782179716364*^-54 + 1.751871851080729*^-54*I, 
       -1.2552702352479827*^-44 + 1.3529195402024307*^-44*I, 
       -5.125286248372498*^-36 + 5.4225534264495375*^-36*I, 
       -1.265421452040981*^-28 + 1.3150015968686779*^-28*I, 
       -2.264409438848249*^-22 + 2.312824214852649*^-22*I, 
       -3.60168235796948*^-17 + 3.618405014668489*^-17*I, 
       -6.356744941674326*^-13 + 6.286859186912994*^-13*I, 
       -1.573556665622369*^-9 + 1.5334385780602492*^-9*I, 
       -6.953503507769092*^-7 + 6.683499517726307*^-7*I, 
       -0.00006991824763692182 + 0.00006635445106200481*I, 
       -0.002031089997009221 + 0.0019053768533830234*I, 
       -0.021445505816894465 + 0.019910458016376725*I, 
       -0.10209709936096771 + 0.09392861921752159*I, -0.26684310145450674 + 
        0.24358421491609908*I, -0.45567227652360187 + 0.4132788379269502*I, 
       -0.5892572785372692 + 0.5317384740571489*I, -0.6493761094023398 + 
        0.5838623070823745*I, -0.6647079942401118 + 0.5963398313602686*I, 
       -0.6659833625102576 + 0.5970470890225598*I}, 
      Line[{0.20500000000000007 + 0.29499999999999993*I, 0.5 + 0.*I}]]}
 
f2b2 = {IFun[{-0.6659833625102576 + 0.5970470890225599*I, 
       -0.6660060238646697 + 0.5970007673099369*I, -0.6658013000452119 + 
        0.5966177030154154*I, -0.6645580486278897 + 0.5951726645470505*I, 
       -0.660955074388544 + 0.5914870860219953*I, -0.6532319260909087 + 
        0.5839961728727145*I, -0.6393320293411547 + 0.5708815174360928*I, 
       -0.6171471376006277 + 0.5502940458357959*I, -0.5848748962772291 + 
        0.5206761160355217*I, -0.5414634931975429 + 0.4811573667485234*I, 
       -0.4870625089813148 + 0.43195019749211916*I, -0.4233448887804371 + 
        0.37462383171455416*I, -0.3535435295989664 + 0.3121194541088484*I, 
       -0.2820914112536931 + 0.24841247666196425*I, -0.2138772770046452 + 
        0.18783943678039128*I, -0.15329285385644964 + 0.1342518142127322*I, 
       -0.10337030117027796 + 0.09026356661338761*I, -0.06530584004796357 + 
        0.056850535510334484*I, -0.038515638047695734 + 
        0.03342243684931124*I, -0.021145794934392902 + 0.018289492209991477*
         I, -0.010785797852777175 + 0.009297588653690932*I, 
       -0.005105797336823835 + 0.004386232909758175*I, 
       -0.002243007960858137 + 0.0019201918955954727*I, 
       -0.0009153361223890473 + 0.0007808396761958353*I, 
       -0.0003477030995592453 + 0.00029555972970983605*I, 
       -0.00012333525538430677 + 0.00010446568027925339*I, 
       -0.000041026669682298856 + 0.00003462605324888994*I, 
       -0.000012866629000015586 + 0.000010820786939355395*I, 
       -3.828741571563626*^-6 + 3.208638999583668*^-6*I, 
       -1.0890418083839072*^-6 + 9.094940307624943*^-7*I, 
       -2.9856277483085324*^-7 + 2.484892045712421*^-7*I, 
       -7.961563290259728*^-8 + 6.604184593536449*^-8*I, 
       -2.0855578773717213*^-8 + 1.7243697795433138*^-8*I, 
       -5.423346667897466*^-9 + 4.469997188614091*^-9*I, 
       -1.4155016562236036*^-9 + 1.1631406880294121*^-9*I, 
       -3.7504715164205834*^-10 + 3.0728801188602743*^-10*I, 
       -1.0205267098162115*^-10 + 8.338411552331462*^-11*I, 
       -2.885280538500231*^-11 + 2.3513252698413544*^-11*I, 
       -8.574422190417256*^-12 + 6.9705439512509525*^-12*I, 
       -2.7089590152671914*^-12 + 2.1972396853404906*^-12*I, 
       -9.199037512033962*^-13 + 7.4457927736814*^-13*I, 
       -3.392785439702411*^-13 + 2.7409608929068197*^-13*I, 
       -1.3724128334791882*^-13 + 1.1068710994863315*^-13*I, 
       -6.143539620504522*^-14 + 4.9475245261947005*^-14*I, 
       -3.0679388116093306*^-14 + 2.4675560215913994*^-14*I, 
       -1.7211030890807373*^-14 + 1.3828488017067725*^-14*I, 
       -1.0910499702528728*^-14 + 8.75907808668405*^-15*I, 
       -7.851948465841697*^-15 + 6.299950953178284*^-15*I, 
       -6.4367517703476494*^-15 + 5.162661117756237*^-15*I, 
       -6.022790099257967*^-15 + 4.830071421127368*^-15*I}, 
      Line[{0.5 + 0.*I, 0.545 - 0.04500000000000001*I}]]}
 
f2b3 = {}
 
I2 = 0.00015381681071488613 - 0.00281663673091117*I
 
p = 0.006907755278982137
 
f3bbtrundom1a = {}
 
g0h1[k_, t_] := g0hnl[k, t]
 
g0hnl[k_, T_] := LevinInt[my3f[k][T], my3g[k][T], my3dg[k][T], 0, T, nfwd, 1, 
     False]
 
my3f[k_][T_][s_] := g0[T - s]*Exp[(-I)*I*Im[k^2]*s]
 
g0[_?InfinityQ] := 0
 
g0[t_] := Exp[-t]
 
my3g[k_][T_][s_] := (-I)*Re[k^2]*s
 
my3dg[k_][T_][s_] := (-I)*Re[k^2]
 
f3bbtrundom2 = {Line[{0.45499999999999996 + 0.04500000000000001*I, 
       0.5 + 0.*I}]}
 
g0t1[k_, t_] := g0tnl[k, t]
 
g0tnl[k_, t_] := LevinInt[my2f[k], my2g[k], my2dg[k], 0, t, nfwd, 1, False]
 
my2f[k_][t_] := g0[t]
 
my2g[k_][t_] := I*k^2*t
 
my2dg[k_][t_] := I*k^2
 
f3bb = {IFun[{-2.2698135670253683*^-15 + 2.869109590366435*^-15*I, 
       -2.4260710674755333*^-15 + 3.06700740905305*^-15*I, 
       -2.960376912115044*^-15 + 3.743872430896403*^-15*I, 
       -4.115620135816837*^-15 + 5.2081008705630725*^-15*I, 
       -6.496903893303251*^-15 + 8.22860581778895*^-15*I, 
       -1.1591574090636139*^-14 + 1.4697424180230016*^-14*I, 
       -2.323790728302511*^-14 + 2.950360725730175*^-14*I, 
       -5.197939745029522*^-14 + 6.609754563458947*^-14*I, 
       -1.2869310889542594*^-13 + 1.6393734878311212*^-13*I, 
       -3.4952369073120826*^-13 + 4.461240067993212*^-13*I, 
       -1.0312245890788357*^-12 + 1.3190803736605537*^-12*I, 
       -3.270782503535009*^-12 + 4.193587722848582*^-12*I, 
       -1.1030826416723773*^-11 + 1.4178465517291053*^-11*I, 
       -3.9110410228322566*^-11 + 5.040404441559141*^-11*I, 
       -1.4410329635027518*^-10 + 1.8623310391241597*^-10*I, 
       -5.453652822511495*^-10 + 7.068572372272246*^-10*I, 
       -2.0955555551096315*^-9 + 2.724262718923911*^-9*I, 
       -8.082965206613012*^-9 + 1.0540552269189472*^-8*I, 
       -3.095432659377863*^-8 + 4.049365851301119*^-8*I, 
       -1.1646262157114581*^-7 + 1.5284395576045968*^-7*I, 
       -4.262577136322165*^-7 + 5.61236661371884*^-7*I, 
       -1.5038488862876172*^-6 + 1.986548455265731*^-6*I, 
       -5.071910412617855*^-6 + 6.721869544042592*^-6*I, 
       -0.000016231704567167393 + 0.000021582512027274517*I, 
       -0.00004897816166311273 + 0.00006533549920780867*I, 
       -0.00013859931190747266 + 0.00018548131733778572*I, 
       -0.0003662550066132658 + 0.0004916916223250187*I, 
       -0.0009009287903311476 + 0.001213227470887703*I, 
       -0.002058633048812037 + 0.002780613281610647*I, 
       -0.004365309246892136 + 0.005913562925599664*I, 
       -0.008590496084819741 + 0.011670336200604344*I, 
       -0.01570504870685521 + 0.021393889475430635*I, -0.02672580671485838 + 
        0.03650206793573402*I, -0.04245338862669676 + 0.05812765875278418*I, 
       -0.06317272786997598 + 0.08670191750633852*I, -0.08843196689628906 + 
        0.12164078497511195*I, -0.1170064371755884 + 0.16128374289281852*I, 
       -0.14708525540184653 + 0.20314167613899775*I, -0.1766245406129399 + 
        0.2443804774930906*I, -0.20374613133088681 + 0.28237454658187283*I, 
       -0.22705599457886283 + 0.3151547457855857*I, -0.24580527826200313 + 
        0.3416408816924239*I, -0.25988504434817744 + 0.3616429039301343*I, 
       -0.26969842625802026 + 0.3756892518110728*I, -0.2759748147241041 + 
        0.38477132053204777*I, -0.27958320770831807 + 0.39008390394222975*I, 
       -0.28137989500355265 + 0.39281155714672644*I, -0.2821027048918425 + 
        0.3939789660643003*I, -0.28230785163367084 + 0.3943606269172755*I, 
       -0.2823378004377042 + 0.3944341978290967*I}, 
      Line[{0.45499999999999996 + 0.04500000000000001*I, 0.5 + 0.*I}]]}
 
I3a = 0.00024132616933222789 + 0.001492254776343729*I
 
f3ctrundom2 = {}
 
g0t2[k_, t_] := g0tnl2[k, t]
 
g0tnl2[k_, t_] := LevinInt[my2f[k], my2g[k], my2dg[k], t, Infinity, nfwd, 1, 
     False]
 
f3c = {}
 
I3c = 0
 
g3[xx_, tt_][_?InfinityQ] := 0
 
g3[xx_, tt_][k_] := I*k*xx - I*tt*k^2
 
dg3[xx_, tt_][_?InfinityQ] := 0
 
dg3[xx_, tt_][k_] := I*xx - 2*I*k*tt
 
g0texactk[tt_][_?InfinityQ] := 0
 
g0texactk[tt_][k_] := g0t1[k, Infinity]*k
 
iii = 0.0002584429222974253 + 0.0015268555261326454*I
